# packages

pkgId: 89eff46086382ece0cd50470f7faca16233dc6499ac43549993f659d1785354d
name: python-SPACEtomo-help
arch: noarch
version: 1.2.0
epoch: 0
release: 1
summary: Development documents and examples for SPACEtomo
url: https://github.com/eisfabian/SPACEtomo
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-SPACEtomo-1.2.0-1.src.rpm
location_href: Packages/python-SPACEtomo-help-1.2.0-1.noarch.rpm
checksum_type: sha256
description:
  Smart Parallel Automated Cryo Electron tomography (SPACEtomo) is a Python package and set of SerialEM scripts to fully automate the cryoET data collection workflow.
  Please refer to the [publication](https://www.nature.com/articles/s41592-024-02373-9) ([pdf](https://rdcu.be/dQlI4)) for more details.

  <img src="https://github.com/eisfabian/SPACEtomo/raw/main/img/SPACEtomo_logo.png" width="600" alt="SPACEtomo" />



  SPACEtomo allows for a variety of automation levels applicable to a range of samples.

  - Automated whole grid montage acquisition, lamella detection and medium mag lamella montage collection is **sample independent** and can be run using a multi-grid workflow.
  - Manual target selection using a user-friendly drag and drop user interface **(sample independent)**.
  - Automated target selection based on segmentation of biological classes in Yeast.



  - [Hardware](#hardware)
  - [Installation](#installation)
  - [Configuration](#configuration)
  - [Usage](#usage)
  	- [Preparation](#preparation)
  	- [Settings](#settings)
  	- [Run](#run)
  	- [Lamella detection GUI](#lamella-detection-gui)
  	- [Target selection GUI](#target-selection-gui)
  	- [CLEM GUI](#clem-gui)
  	- [Output](#output)
  	- [External Processing](#external-processing)
  - [Video tutorials](#video-tutorials)
  - [Troubleshooting](#troubleshooting)
  - [Recent changes](#recent-changes)
  - [Future plans](#future-plans)
  - [Training Data](#training-data)



  SPACEtomo has only been tested on Thermo Scientific Krios instruments equipped with a Gatan K3 or K2 direct electron detector at this point although it should also work on other Thermo Scientific instruments. A recent version of the open-source microscope control software [SerialEM](https://bio3d.colorado.edu/SerialEM/) should be installed and calibrated. It also requires the [PACEtomo](https://github.com/eisfabian/PACEtomo) scripts.



  SPACEtomo requires SerialEM 4.1.8 or higher capable of running Python (>=3.9) scripts.

  NOTE: A Gatan K2 computer does not support Python >3.7. You can use Python 3.6 together with an external workstation running Python >=3.9 (details [below](#external-processing)).

  You can run the following lines of code in a SerialEM script window to test if Python is configured correctly:
  ```python

  import serialem as sem
  sem.OKBox("Python works!")
  ```
  If you get an error message, please consult the [SerialEM website](https://bio3d.colorado.edu/SerialEM/hlp/html/about_scripts.htm#Python) on how to setup Python for SerialEM.



  Additionally, you will require several Python packages. It is best practice to create a virtual environment for SPACEtomo running Python 3.9 or higher ([SerialEM compatible versions of Python](https://bio3d.colorado.edu/SerialEM/hlp/html/about_scripts.htm#pythonInstall)).

  After [installing your desired Python version](https://docs.python.org/3/using/windows.html#the-full-installer) (following commands assume Python 3.9, since most testing was done in this version), create a folder for your virtual environment and run:

      C:\Python39\python -m venv <path_to_your_venv>

  To activate the virtual environment run:

      <path_to_your_venv>\Scripts\activate.bat

  The next step will be much easier if you have a network connection. Please contact your responsible IT specialist if it's possible to temporarily allow network connection or setup a proxy.

  With network connection, you can run:

      pip install --extra-index-url https://download.pytorch.org/whl/cu118 SPACEtomo[gui,predict]

  With proxy, you can run:

      pip install --proxy <proxy_address> --extra-index-url https://download.pytorch.org/whl/cu118 SPACEtomo[gui,predict]

  The `--extra-index-url` is only necessary if you want to use a CUDA enabled GPU for the prediction tasks. The given URL is for **CUDA 11.8**. You can check the [PyTorch download site](https://pytorch.org/get-started/locally/) for URLs to install different CUDA versions!

  NOTE: If the installation fails, you can try `SPACEtomo[gui]` or only `SPACEtomo` to install the minimal environment. In that case you will require an external machine to run any deep learning dependent tasks.

  <details>
   <summary>Without any network connection, you will have to go through these steps on another Windows machine (e.g. the microscope support PC).</summary>

  (The Windows machine should be as similar in hardware and software as possible to the SerialEM computer.)

  1. Setup the same python version and virtual environment.
  2. Create a new folder to save the python packages.
  3. In this folder, run:

      ```pip download --extra-index-url https://download.pytorch.org/whl/cu118 SPACEtomo[gui,predict]```

  4. Copy this folder to the SerialEM computer.
  5. On the SerialEM computer, open the command prompt and activate the virtual environment with `<path_to_your_venv>\Scripts\activate.bat`.
  6. Navigate to the folder containing the downloaded Python packages and ensure it does not contain anything else!
  6. In this folder on the SerialEM computer, run:

  ```
  FOR %i in (*) DO python -m pip install --no-deps %i
  ```

  If no error messages appear, all necessary packages should be successfully installed. If there are errors, you will have to resolve any compatibility issues. The easiest would be to try the same procedure on a Windows machine more similar to the SerialEM computer.

  [Here](https://github.com/eisfabian/SPACEtomo/blob/main/docs/package_list.md) you can find a list of packages and versions that works on our Gatan K3 and K2 computers.

  </details>

  NOTE: If you are running SPACEtomo on a Gatan K3 control PC, you might get a warning about your Nvidia driver being too old. I updated the driver on several Gatan PCs without problem, but please consult your IT responsible before updating it. If you cannot update your driver, you can still run lamella detection models locally on the CPU, but lamella segmentation will require [external processing](#external-processing).



  With that, all dependencies should be ready to go!

  To let SerialEM access this environment, we have to adjust the *SerialEM_properties.txt* file to include the Python path to the folder containing our environment's *python.exe*:

      PathToPython	3.9 	<path_to_your_venv>\Scripts






  To install SPACEtomo, you will have to import the deep learning models and adjust the config file.

  After activating your virtual environment in the command prompt with

      <path_to_your_venv>\Scripts\activate.bat

  you can run the `SPACEmodel` command:

      SPACEmodel list                                 # Lists all imported models
      SPACEmodel add --path <path_to_model_file>      # Imports model (.zip for segmentation model, .pt for detection model)
      SPACEmodel add --url <url_to_model_file>        # Downloads and imports model
      SPACEmodel activate --name <name_of_model>      # Activates model (1 detection and 1 segmentation model are necessary)
      SPACEmodel remove --name <name_of_model>        # Removes model
      SPACEmodel clear                                # Removes all models

  There are 2 types of SPACEtomo models:
  1. Lamella detection models that use whole grid maps to identify lamella sites.
  2. Lamella segmentation models that use medium magnification maps of a lamella to create a segmentation.

  [You can find information on all currently supported models here!](https://github.com/eisfabian/SPACEtomo/blob/main/docs/model_info.md)

  NOTE: If you train your own models, please consider sharing them with the community!



  You should also adjust the config file if you use a new model. You can access the config.py file using the `SPACEconfig` command:

      SPACEconfig get --name <file_name>              # Fetches a copy of config.py and saves it to the current directory as <file_name>
      SPACEconfig set --name <file_name>              # Applies <file_name> (config.py by default) as new config file

  You can edit and adjust the config.py like a text file for your needs.

  <details>
      <summary><b>Model specific config entries</b></summary>

  - `WG_model_file`: Path to lamella detection model (automatically configured by `SPACEmodel add`).
  - `WG_model_pix_size`: Pixel size of lamella detection model in nm.
  - `WG_model_sidelen`: Side length of images used for detection model in pixel.
  - `WG_model_categories`: List of category names distinguished by lamella detection model.
  - `WG_model_gui_colors`: List of colors used in GUI to represent lamella categories.
  - `WG_model_nav_colors`: List of colors used in SerialEM to represent lamella categories.

  - `MM_model_script`: Name of script called for lamella segmentation (currently only nnU-Net is supported).
  - `MM_model_folder`: Path to lamella segmentation model (automatically configured by `SPACEmodel add`)
  - `MM_model_folds`: Folds of nnU-Net model (automatically configured by `SPACEmodel add`).
  - `MM_model_pix_size`: Pixel size of lamella segmentation model in nm.

  </details>

  <details>
      <summary>Settings for controlling SerialEM externally (not yet fully supported)</summary>

  - `SERIALEM_IP`: IP of computer running SerialEM (default: "127.0.0.1" for local computer).
  - `SERIALEM_PORT`: Port for SerialEM connection (default: 48888)
  - `SERIALEM_PYTHON_PATH`: Path to Python modules on external machine

  </details>
  <details>
      <summary>Settings for development and debugging</summary>

  - `DUMMY`: Allows testing of some functions without SerialEM (default: False).
  - `DEBUG`: Additional log output for troubleshooting (default: False).

  </details>
  <details>
      <summary><b>Persistent acquisition settings</b></summary>

  - `WG_montage_overlap`: Overlap between neighboring tiles of the LM map for stitching.
  - `WG_detection_threshold`: YOLOv8 confidence threshold for considering a hit a lamella. Raise this value if you have a lot of false positives.

  - `MM_montage_overlap`: Overlap between neighboring tiles of the MM map for stitching. Good stitching is especially important here for reliable target selection.
  - `MM_padding_factor`: MM maps are padded by this factor compared to the lamella bounding box. This accounts for the coordinates being off center or the bounding box prediction being off.

  - `aperture_control`: [Does SerialEM have control over the apertures](https://bio3d.colorado.edu/SerialEM/hlp/html/setting_up_serialem.htm#apertures)?
  - `objective_aperture`: Size of objective aperture to be inserted when leaving LM.

  </details>




  The final step before you can run SPACEtomo is to copy the [SerialEM scripts](https://github.com/eisfabian/SPACEtomo/tree/main/SPACEtomo/SerialEM_scripts) into the SerialEM script window.
  Simply copy the [SPACEtomo_run.py](https://github.com/eisfabian/SPACEtomo/tree/main/SPACEtomo/SerialEM_scripts/SPACEtomo_run.py) script and the [SPACEtomo_postAction.py](https://github.com/eisfabian/SPACEtomo/tree/main/SPACEtomo/SerialEM_scripts/SPACEtomo_postAction.py) script into a SerialEM script window each.

  If you installed SPACEtomo, you can also run this command to retrieve a copy of the SerialEM scripts:

      SPACEtomo scripts

  You also need the [PACEtomo scripts](https://github.com/eisfabian/PACEtomo) (v1.7+) ready and working inside SerialEM. All tilt series acquisition steps are conducted by PACEtomo, so please setup up your scripts and Low Dose settings according to the PACEtomo documentation.

  Optional: You can also copy the [SPACEtomo_lamellaDetectionGUI.py](https://github.com/eisfabian/SPACEtomo/tree/main/SPACEtomo/SerialEM_scripts/SPACEtomo_lamellaDetectionGUI.py) and the [SPACEtomo_targetSelectionGUI.py](https://github.com/eisfabian/SPACEtomo/tree/main/SPACEtomo/SerialEM_scripts/SPACEtomo_targetSelectionGUI.py) to a SerialEM script window to easily open the [SPACEtomo GUIs](#lamella-detection-gui) from SerialEM.



  If you want to update SPACEtomo to the latest version, simply activate your virtual environment and run:

      pip install SPACEtomo

  with network connection or:

      pip install --proxy <proxy_address> SPACEtomo

  using a proxy.

  SPACEtomo models should be retained but please double-check that your config file is still valid!



  The usage instructions for SPACEtomo assume that [PACEtomo](https://github.com/eisfabian/PACEtomo) is already able to run normally on your setup.



  SPACEtomo requires the setup of at least 2 image states in the SerialEM navigator.

  - One image state for whole grid montages (LM maps), at a pixel size <400 nm/px (including binning).
  - One Low Dose mode image state with a View magnification for lamella montages (MM maps), ideally at pixel sizes <2.2 nm/px and a defocus offset of 50-100 μm, as well as the desired Record settings for tilt series acquisition. The smaller the beam diameter in Record mode, the more targets can be selected per lamella.

  Additionally, an intermediate magnification (IM) might be required to compensate for the coordinate shifts between the low mag and the View mag. This magnification should contain the lamella fully in the FOV when moving the stage to a position on the LM map and it should be fairly well aligned to the View mag.
  <details>
  	<summary>Details</summary>
  When selecting and moving to a point on an LM map, then taking a View image, the selected point will most likely not be in the field of view. Usually, I find that point manually and use the <i>Navigator</i> > <i>Shift to Marker</i> function to adjust the coordinates.

  To automate this, SPACEtomo moves to a lamella found on the LM map and takes an image at IM that needs to fully contain the lamella despite the offset. It then runs the same lamella detection model and shifts the coordinates to the newly found lamella. The jump from the IM to the View magnification in your Low Dose image state should be minimal since no further compensation is applied.
  </details>

  For optimal results, it is recommended to check or redo the "Mag IS Offsets" calibration for the relevant magnifications.

  The "High-Defocus Mag" and especially the "High-Defocus IS" calibrations also help to keep a feature centered when switching from the *View* to the *Record* Low Dose area.

  The magnifications I use are 82x for LM, 580x for IM and 4800x for MM.

  If you intend to do a [coma-free alignment](https://bio3d.colorado.edu/SerialEM/hlp/html/menu_focus.htm#hid_focus_coma_by_ctf) and a [coma vs image shift calibration](https://bio3d.colorado.edu/SerialEM/hlp/html/hidd_coma_vs_is_cal.htm), this should be done prior to running SPACEtomo ideally on a carbon support foil grid.

  <details>
      <summary>Further recommendations for SerialEM setup</summary>

  - In the Image alignment & Focus Panel, check *Center image shift on tilt axis* and set tilt axis offset as described in the [PACEtomo](https://github.com/eisfabian/PACEtomo) documentation.
  - Set both, Focus and Trial to offset 0.
  - Align shift between Record and View magnifications.
  </details>



  All session settings are adjusted in the [SPACEtomo_run.py](https://github.com/eisfabian/SPACEtomo/tree/main/SPACEtomo/SerialEM_scripts/SPACEtomo_run.py) script. They are categorized by automation level and settings beyond your chosen automation level will not be relevant.

  The most important settings for the first setup that remain mostly unchanged from session to session are:

  | Setting | Description |
  | ------- | ----------- |
  | `WG_image_state` | Image state index used for LM map (grid atlas). |
  | `MM_image_state` | Image state index used for Low Dose mode tilt series acquisition. This can be a list of imaging states to specify imaging states for Record and View separately. |
  | `IM_mag_index` | The mag index (e.g. 10) of the intermediate magnification or the magnification itself (e.g. 580). |
  | `script_numbers` | List of indices of the [[SPACEtomo_run.py](https://github.com/eisfabian/SPACEtomo/tree/main/SPACEtomo/SerialEM_scripts/SPACEtomo_run.py), [SPACEtomo_postAction.py](https://github.com/eisfabian/SPACEtomo/tree/main/SPACEtomo/SerialEM_scripts/SPACEtomo_postAction.py), [PACEtomo.py](https://github.com/eisfabian/PACEtomo/blob/main/PACEtomo.py)] scripts in the SerialEM script editor. |

  The settings that will typically change from run to run are:

  | Setting | Description |
  | ------- | ----------- |
  | `automation_level` | Level 1-5 from only taking the WG map to starting the PACEtomo batch acquisition. |
  | `external_map_dir` | Shared folder when running the processing on an external machine ([see below](#external-processing)). |
  | `grid_list` | List of autoloader slots to be imaged (comma-separated in []-brackets). |
  | `WG_wait_for_inspection` | Pause SPACEtomo before collecting lamella MM maps until detected lamellae have been inspected using the [SPACEtomo lamella detection GUI](#lamella-detection-gui) |
  | `exclude_lamella_classes` | List including all classes that will not be further processed. Possible classes depend on the [detection model](https://github.com/eisfabian/SPACEtomo/blob/main/docs/model_info.md#lamella-detection-models) you are using. |
  | `MM_wait_for_inspection` | Pause SPACEtomo before acquisition until selected targets have been inspected using the [SPACEtomo target selection GUI](#target-selection-gui) |
  | `manual_selection` | Skip segmentation step (for samples without trained model) and use [SPACEtomo target selection GUI](#target-selection-gui) for target selection. |
  | `target_list` | List including all classes of the segmentation that are targeted. Examples for all classes can be found [here](https://github.com/eisfabian/SPACEtomo/raw/main/img/class_examples.png). |
  | `avoid_list` | List including all classes that should be avoided. |
  | `target_score_threshold` | Can be adjusted to reduce the number of targets. The score is calculated from the overlap of the camera field of view with the segmented classes. The score is not linear, but ranges from 0 to 1, from no target area in the FOV to the FOV being completely covered. A desired class in the center of the camera is upweighted. Generally, larger targets (e.g. nucleus or cell) are more robust to higher thresholds. Classes to be avoided in the FOV can cause a negative score. |
  | `sparse_targets` | Target selection mode useful for small targets like mitochondria or vesicles. If set to `False`, a rigid grid of points is used for initial target selection, which is more suited to large target areas. |
  | `target_edge` | Can be set to `True` to target the edges of a segmented class. This could be useful for membrane structure studies (e.g. NPCs). |
  | `penalty_weight` | Factor to downweight the classes of the `avoid_list` relative to the classes of the `target_list`. |
  | `extra_tracking` | Set to `True` if you want to add an extra target for the tracking tilt series that does not contain your desired class.
  | `max_tilt` | This is the maximum tilt angle during a tilt series. It is used to calculate target spacing without any beam overlap. You can use lower values if you don't care about high angle overlaps and rather have more targets. |

  Additional settings are available in the [config.py](#config), which should generally only need adjustments when updating the deep learning models.



  You can run SPACEtomo at different automation levels. It will stop after reaching the final automation level and will let you manually finish the setup if you desire.

  <img src="https://github.com/eisfabian/SPACEtomo/raw/main/img/workflow_levels.png" alt="Automation levels" />



  * SPACEtomo will load a grid, collect a LM map of the whole grid and identify the positions of lamellae. Navigator items labeled "PL#" ("Preliminary Lamella") will be added in SerialEM. It will then take another image of each lamella at intermediate magnification (IM) to adjust the stage coordinates accordingly and add a navigator item with label "FL#" ("Final Lamella"). If you stop at level 1, you can manually move to the identified lamella and decide where you want to collect a montage or select targets using [PACEtomo_selectTargets.py](https://github.com/eisfabian/PACEtomo/).



  * This level includes collection of MM maps of each lamella. You can then use these maps for manual target selection. Level 2 is organism independent and should be able to be used for any kind of lamella sample.



  * Level 3 includes the subsequent segmentation of the lamella montages for manual inspection. This model is organism specific (only Yeast at the time of writing) and new models will be released in the future.
  * If you intend to collect lamellae exhaustively, you can use the Yeast model and include "lamella" in the first entry of your *target_list*. This allows the target setup to use the organism independent classes (e.g. "black", "white", "ice", etc.) to avoid and set up targets everywhere else on the lamella.
  * If you set `manual_selection = True`, segmentation will be skipped.



  * SPACEtomo will use the generated segmentation to set up targets according to your target selection settings. If you stop at level 4, you will be able to review all selected targets or add additional targets using the [Target selection GUI](#target-selection-gui) or the [PACEtomo_selectTargets.py](https://github.com/eisfabian/PACEtomo/) script.



  * The highest level of automation will start SerialEM's [Acquire at Items](https://bio3d.colorado.edu/SerialEM/hlp/html/hidd_navacquire.htm) routine. Make sure to set it up accordingly in advance.
  * You have to select the [PACEtomo.py](https://github.com/eisfabian/PACEtomo/blob/main/PACEtomo.py) script as the *Primary Action* and make sure that the PACEtomo settings in the script have been set appropriately. Especially consider these settings when running SPACEtomo:
  	 * If you want to use the by SPACEtomo automatically determined geo points for sample geometry measurement, set `measureGeo = True`.
  	 * Set the appropriate `pretilt` and `rotation` values if you don't want to measure the geometry.
  	 * Either set `previewAli = False` and `viewAli = True` to use the SPACEtomo generates view mag virtual maps for alignment or set `previewAli = True` and `viewAli = False` to use SerialEM's (>=4.2) *AlignBetweenMags* function to align a Preview image to the View mag virtual maps. The latter requires some high contrast features in the field of view to work reliably, but offers higher targeting precision for the final tilt series.
  * No further tasks in the *Acquire at Items* dialog are necessary. PACEtomo will realign to the target and run a eucentricity routine. (You can check "Skip Z" moves during realign.)
  * Additionally, you have to set the [SPACEtomo_postAction.py](https://github.com/eisfabian/SPACEtomo/tree/main/SPACEtomo/SerialEM_scripts/SPACEtomo_postAction.py) script as `Run Script after Action`. This script will monitor any finishing lamella segmentation that was not ready for target setup before the PACEtomo acquisition started.
  * There will be no break to do additional microscope alignments before the tilt series acquisition starts. It is recommended to do all necessary alignments (e.g. Beam Tilt PP, coma-free alignment, Coma vs IS calibration, center OL aperture) prior to running SPACEtomo on a carbon film grid.



  If you want to run multiple grids in succession without intervention you can give a list of grids as `grid_list`. In this case the grid list will be saved as persistent variable inside SerialEM. If you restart the SPACEtomo script later in the same session with a different grid list, you need to run the *ClearPersistentVars* command in the SerialEM *One-Line Scripts* panel to ignore the previously given grid list.

  While it is possible to run target setup in multi-grid mode, I would not recommend it as the target coordinates might be off after reloading a grid. The SerialEM 4.2beta multi-grid procedure to realign grids after reloading is currently untested.



  The lamella detection GUI can be used to open whole grid LM maps and visualize detected lamella bounding boxes. You can also add, remove and re-categorize lamellae.

  If you selected `WG_wait_for_inspection = True`, the GUI should open automatically. You can also open it using this command in the command prompt of your virtual environment:

      SPACEtomo lamella

  You can then find a map image to load. If you want to visualize the results of the automatic lamella detection, go to the SPACE_maps folder created by SPACEtomo during a run and select any file ending with "_wg.png". The GUI will automatically look for any relevant "_boxes.json" file to load lamella coordinates and bounding boxes.

  <img src="https://github.com/eisfabian/SPACEtomo/raw/main/img/SPACEtomo_lam.png" alt="Lamella detection GUI" />


  On the top left you will find the `Find map` and `Next` buttons to load a WG map.

  Once a map is loaded and lamella coordinates are found, a list of all lamellae is displayed with color-coded classes and confidence scores. If you click on a lamella name, its bounding box will be centered in the plot.

  Right clicking on a lamella in the plot or clicking `Edit` in the list, will open the editing menu allowing you to re-categorize, delete or reorder any lamella.

  You can resize and drag the lamella bounding boxes by holding left click and dragging the corners or sides of the box.

  You can also add a new lamella by holding `Shift` and dragging the left mouse button to draw a bounding box.

  `Mark as inspected` will lock down any editing capabilities and signal SPACEtomo that it can proceed with the next automation step.

  Finally, you can use the `Export tiles` button to export the map and bounding boxes in YOLO format that can later be used for training a new lamella detection model. This data can be found in the *YOLO_dataset* folder. Please consider submitting this data to me to further improve the general SPACEtomo lamella detection model in the future.



  The target selection GUI can be used to inspect a segmentation and selected targets, run automated target selection with different parameters and manually select and edit targets.

  If you selected `MM_wait_for_inspection = True`, the GUI should open automatically. You can also open it using this command in the command prompt of your virtual environment:

  	SPACEtomo targets <path_to_SPACE_maps_folder>

  The GUI will make a list of all collected lamella MM maps and lets you select a map to load (takes a minute depending on map size).

  If targets have already been selected, it will also show the target positions on the map. You can either run automated target selection again with different parameters, drag targets to a new position, add and remove targets and mark targets as *inspected*, which allows SPACEtomo to use the coordinates for target setup.

  <img src="https://github.com/eisfabian/SPACEtomo/raw/main/img/SPACEtomo_tgt.png" alt="Target selection GUI" />

  The left menu consists of 2 sections - map loading and a list of classes.

  `Load map` will load the map selected in the drop down menu, `Next` will load the following map and the `[]` button will open a window with an overview over all lamellae.

  If you want to reopen the whole grid map you can click on `Grid map` to restart the [Lamella detection GUI](#lamella-detection-gui). The `CLEM` button will open the [CLEM GUI](#clem-gui) to facilitate correlated target selection.

  In case the segmentation step was performed, you can check the boxes of any number of segmented classes in the shown list and click `Create overlay` to show a red overlay of all selected classes over the map or `Apply` to use the selected classes as target classes for automated target selection.

  The center plot shows the lamella map as well as the selected targets and geo points. (Geo points will be used to estimate the sample geometry by measuring their relative z-height using SerialEM's autofocus routine.)

  - Blue rectangle: Camera field of view (FOV) at Record magnification on target
  - Red rectangle: Camera FOV on tracking target
  - Orange rectangle: Camera FOV at geo point
  - Yellow ellipse: Area exposed to electron beam throughout a tilt series up to the `max_tilt` angle.
  - Orange circle: Area exposed to electron beam around geo point at zero tilt.
  - Blue/white dots: Center coordinates of respective areas colored by independent target area (= PACEtomo acquisition area). These dots can be dragged to move targets.

  You can right click on any target to `Delete` it, make it a tracking target or optimize its position locally based on the active class selection mask.

  The right menu consists of 3 sections - target selection, acquisition settings and saving.

  The target selection settings are the same as described [above](#settings). You can adjust the settings and rerun the target selection by clicking `Auto select targets`.

  `Split target areas` will attempt to split the targets into 2 independent target areas using k-means clustering. You can then right click on any target and manually move it between target areas using the drop down menu. This can be useful for large lamellae where the image shift limit is not sufficient to collect all targets in parallel. `Redistribute targets` will simply assign all targets to the closes tracking area. To merge target areas you can click `Merge target areas`.

  `Delete targets` will clear all targets and geo points from the list and plot. `Delete geo points` will clear just the geo points.

  The acquisition settings can be used to override any settings specified in the *PACEtomo* script.

  Finally, `Mark as inspected` will lock down any editing capabilities and signal SPACEtomo that it can proceed with the next automation step.



  The correlative light and electron microscopy (CLEM) interface allows for loading, registration and overlaying of light microscopy data to enable target selection based on fluorescent signals. It is a sub-window of the [Target selection GUI](#target-selection-gui) and can be opened via the `CLEM` button.

  <img src="https://github.com/eisfabian/SPACEtomo/raw/main/img/SPACEtomo_clem.png" alt="CLEM GUI" />

  Please load your lamella EM map first as this will reset the CLEM window. After loading your lamella EM map, you can click `Find LM map` to load single channel PNG or TIF files.

  After loading all your channels, you can adjust them separately using the Channel table on the left. Adjustments include color (R, G, B, W), where "W" will keep the original colors of the image, hiding the channel using the checkbox and thresholding using maximum and minimum sliders. The histogram indicates the currently set thresholds using orange lines.

  To align EM and LM map, you can add registration points by left clicking on the respective maps. A minimum of 3 points is necessary to calculate the transformation matrix but more are possible. You can also drag existing registration points.

  The `Transform` button will overlay the LM channels on the EM map. You can still adjust the thresholds and hide channels you don't want to see. If you close the CLEM window, the same overlay is also visible on the Target selection plot.

  You can now proceed with normal target selection. When you load a new lamella EM map, all LM maps are cleared.



  * SPACEtomo will create a subfolder, navigator file and log file for each grid. Any kind of montages and frames are saved according to SerialEM settings.
  * All images processed by SPACEtomo and results are saved to a *SPACE_maps* folder OR to the folder specified as `external_map_dir` for the SPACEtomo run.
      * Images and montage maps are rescaled to the pixel size of the respective models and saved as PNG images.
      * Lamella bounding boxes are saved in **_boxes.json* files.
      * Target coordinates are saved in **_points.json* files.
      * Segmentation files are saved with the suffix *_seg* for each MM map. Each segmentation inference produces a **_SPACE.log* and a **_SPACE.err* file for debugging.
      * The *SPACE_runs.json* contains the processing jobs and queue.
  * The *mic_params.json* and *tgt_params.json* files are necessary to schedule the inference jobs and run the target selection GUI.
  * The *SPACEtomo_settings.ini* file contains the settings for the run.
  * The *_tgts.txt* files are PACEtomo targets files that are used for acquisition.
  * Tilt series are output as specified by your SerialEM and PACEtomo settings.



  Depending on your setup, the GPU on the computer running SerialEM might not be powerful enough or not even present. On some systems the OS might also be too old to run some of the required Python packages. In these cases you can install the minimal environment on the SerialEM computer and run most processing steps on an external GPU machine.

  To process on an external machine you can specify an `external_map_dir` in the [settings](#settings) of the [SPACEtomo_run.py](https://github.com/eisfabian/SPACEtomo/tree/main/SPACEtomo/SerialEM_scripts/SPACEtomo_run.py) script. This directory has to be accessible via the network both by the computer running SerialEM and by the external GPU machine.

  The external GPU machine requires the same Python packages (full environment) as described [above](#installation) but no SerialEM. Before starting the SPACEtomo run in SerialEM, you can then simply activate the conda environment and run the monitor script:

  	source <path_to_your_venv>/bin/activate
  	SPACEmonitor --dir <path_to_external_map_dir> --gpu <comma-separated_list_of_GPUs>

  The monitor script will check the map dir periodically, queue any maps to be analyzed, save the segmentation to the same directory and run the target selection algorithms.

  SPACEtomo on the SerialEM computer will keep checking the map dir for new coordinate files and setup the targets when appropriate. For inspection of the maps and targets you can run the `SPACEtomo targets <path_to_external_map_dir>` command as described [above](#target-selection-gui) either on the SerialEM computer or on the external machine.



  [![SPACE-tomo: Target Selection GUI](https://github.com/eisfabian/SPACEtomo/raw/main/img/SPACE_tut_thumbnail_tgt.png)](https://www.youtube.com/watch?v=I5yvi0sUGG4)

  More coming as soon as possible!



  In general, if you run into any crashes or problems, please turn on debug output using `SPACEconfig debug` in a command prompt with activated SPACEtomo virtual environment. Then run SPACEtomo again and include the SerialEM log file when you report the issue!

  Here are some common problems that might occur:

  - In case your lamella montages don't stitch properly, you might need to experiment with the SerialEM montage settings and with the overlap factors in the SPACEtomo config. Redoing the *High Defocus Mag* calibration might also help.
  - If SPACEtomo freezes or crashes when loading an image from the SerialEM buffer, please try just running it again. This issue with SerialEM is still under investigation.
  - If you get an Error about the stage limits during the WG montage acquisition, go to Navigator -> Grid limits and adjust the limits until you can use *Setup Full Montage* without having to adjust the number of tiles.
  - If you get an error saying something like `unexpected keyword argument 'perform_everything_on_XXX`:
    - nnUNet changed the name of the argument recently from `perform_everything_on_gpu` to `perform_everything_on_device`.
    - Please try to change it accordingly in the *SPACEtomo_nnUNet.py* script (SPACEtomo v1.1) and try running it again.
  - If your tilt series are off target, check if your Record and View mag are aligned in the used image state and consider doing the "High-Defocus IS" calibration for your View mag.
  - If your lamella is not in the field of view when switching between low mag and intermediate mag or between intermediate mag and View mag, redo the "Mag IS Offsets" calibrations.
  - If SerialEM terminates the script with a montage error concerning an exceeded limit in the Script Control, go to *Scripts* > *Controls* and remove any limits that cause the script to terminate.
  - If SPACEtomo does not detect any lamellae although lamellae are clearly visible on your WG map, try collecting the map with the energy filter slit in to improve contrast. Please also consider sharing your WG maps with me so I can further improve the lamella detection model!
  - If the Navigator keeps asking you to save, check your *SEMshortTermCal.txt*. If there is a line starting with `NavAutosave`, delete it.
  - To be continued...




  - New lamella detection model trained on 3x the training data of the first model.
  - New lamella detection GUI allowing for inspection and manual intervention.
  - Improved target selection GUI:
      - Added options for multiple target areas.
      - Added acquisition settings to override PACEtomo settings.
      - Sped up map loading by ~30%.
      - Added basic fluorescence map loading, registration and overlay for targeting.
  - Added command line interface to manage models, open GUIs and monitor folder for external processing.
  - Refactored most code to facilitate deployment as Python package.
  - Lots of bug fixes and quality of life improvements.


  - Refactored most code to run on external machine and only run SerialEM dependent steps on microscope machine.
  - Added GUI for target selection and inspection.
  - Allowed for manual target selection.
  - Allowed for inspection of targets before acquisition.
  - Added multi-grid acquisition.
  - Added splitting of collection areas when lamella too big for all targets to be accommodated within image shift limits.
  - Added multi GPU support for external processing.
  - Made rudimentary interface for training new segmentation models.
  - Lots of bug fixes.
  - Minor text fixes.


  Release!



  - Segmentation models for Chlamydomonas and eukaryotic cells
  - Better framework for training your own models
  - To be continued... (Let me know if you have wishes or ideas!)



  [SPACEtomo training dataset for lamella detection using YOLOv8](https://doi.org/10.5281/zenodo.10360315)

  [SPACEtomo training dataset for Yeast lamella map segmentation using nnU-Netv2](https://doi.org/10.5281/zenodo.10360344)

  The segmentation models are based on [nnU-Net](https://github.com/MIC-DKFZ/nnUNet). To train a new model you will need an image file and a segmentation file with a particular pixel value for each class. You can find further instructions [here](https://github.com/MIC-DKFZ/nnUNet/blob/master/documentation/dataset_format.md).

  The SPACEtomo training interface (*SPACEtomo TI*) is a rudimentary interface for training your own model using a human-in-the-loop approach. You can find instructions [here](https://github.com/eisfabian/SPACEtomo/blob/main/docs/SPACEtomo_TI.md).

  The interface will guide you through data preparation from lamella maps in .mrc format, conversion to .png files for each class and training of the model in an iterative fashion. However, the actual labeling requires external graphics editing software like *Adobe Photoshop*, [GIMP](https://www.gimp.org/) or [Napari](https://napari.org/).

  For my training set, I used Photoshop to segment different classes on different layers by hand. Why Photoshop? My main reason was the support for comfortable labeling using a drawing tablet with pressure sensitivity. I saved each layer as png file separately and used a Python script to combine these images into a single segmentation image.
  Another script would take the segmentation and output layer images that I could then edit and refine in Photoshop for retraining.

  I also want to mention [OpenFIBSEM](https://demarcolab.github.io/openfibsem-docs/autolamella/ml/), which includes a Napari-based labelling workflow that can be adapted for nnU-Net. This workflow can make use of general segmentation models for assisted labeling.



  I want to thank all the people who provided training data for the deep learning models:
  - Anna Bieber (MPI Martinsried)
  - Cristina Capitanio (MPI Martinsried)
  - Matthias Pöge (MPI Martinsried)
  - Sven Klumpe (MPI Martinsried)
  - Gregor Weiss (ETH Zurich)
  - Yoshiyuki Fukuda (Tokushima University / University of Tokyo)
  - Helena Watson (Rosalind Franklin Institute)
  - Corina Hadjicharalambous (ETH Zurich)
  - Jannik Hugener (ETH Zurich)
  - Karolina Roganowicz(ETH Zurich)
  - Lee Rettberg (ETH Zurich)
  - Miriam Weber (ETH Zurich)
  - Marlen Petersen (ETH Zurich)
  - Tobias Zachs (ETH Zurich)
  - Vasil Gaisin (ETH Zurich)
  - Yun-Wei Lien (ETH Zurich)

  Special thanks to Pavel Afanasyev for guiding me on my way to stepping up my Python level.

  Thanks to all the members of the Pilhofer lab who let me troubleshoot SPACEtomo on their samples!
  I also want to thank Patrick Cleeve for his contributions and everyone who gave me feedback and gave SPACEtomo a try!

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: 5049569c084683e729d31d6bc4a812e171a8c83cf683a8b345f3cfdfaf33d352
name: python-SPLayout-help
arch: noarch
version: 0.5.14
epoch: 0
release: 1
summary: Development documents and examples for SPLayout
url: https://github.com/Hideousmon/SPLayout
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-SPLayout-0.5.14-1.src.rpm
location_href: Packages/python-SPLayout-help-0.5.14-1.noarch.rpm
checksum_type: sha256
description:
  |GitHub repository| |GitHub license|
  SPLayout (**S**\ilicon **P**\hotonics **Layout** Design Tools) is a silicon photonics structures design package. It provides commonly used silicon photonics structures for fast integration and pixelated blocks for inverse design.
  The GDSII streaming is based on gdspy(https://github.com/heitzmann/gdspy) and FDTD simulation is executed on Ansys Lumerical.


pkgId: 1b45bf4cc84f78849953d152dbc42f641c3adfccc575465f9b77f490649c9be5
name: python-SQLExecX-help
arch: noarch
version: 2.1.5
epoch: 0
release: 1
summary: Development documents and examples for SQLExecX
url: https://gitee.com/summry/sqlexecx
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-SQLExecX-2.1.5-1.src.rpm
location_href: Packages/python-SQLExecX-help-2.1.5-1.noarch.rpm
checksum_type: sha256
description:
  Usage Sample
  ''''''''''''

  .. code:: python

         import sqlexecx as db

         if __name__ == '__main__':
             db.init('test.db', driver='sqlite3', show_sql=True, debug=True)

             
             db.init("postgres://user:password@127.0.0.1:5432/testdb", driver='psycopg2', pool_size=5, show_sql=True, debug=True)

             
             db.init(host='127.0.0.1', port='5432', user='xxx', password='xxx', database='testdb', show_sql=True, driver='psycopg2')

             effected_rowcount = db.insert(table='person', name='zhangsan', age=15)

             
             select_key = "SELECT currval('person_id_seq')"

             id = db.save(select_key=select_key, table='person', name='lisi', age=26)

             id = db.save_sql(select_key, 'INSERT INTO person(name, age) VALUES(?,?)', 'wangwu', 38)

             id = db.save_sql(select_key, 'INSERT INTO person(name, age) VALUES(:name, :age)', name='zhaoliu', age=45)

             count = db.get('select count(1) from person')
             

             count = db.sql('select count(1) from person').get()
             

             persons = db.select('select id, name, age from person')
             
             
             
             
             

             persons = db.sql('select id, name, age from person').select()
             
             
             
             
             

             persons = db.table('person').select('id', 'name', 'age')
             
             
             
             
             

             persons = db.select_one('select id, name, age from person where name = ?', 'zhangsan')
             
             

             persons = db.sql('select id, name, age from person where name = ?').select_one('zhangsan')
             
             

             persons = db.select('select id, name, age from person where name = :name', name='zhangsan')
             
             

             persons = db.sql('select id, name, age from person where name = :name').select(name='zhangsan')
             
             

             persons = db.sql('select id, name, age from person where name = :name').param(name='zhangsan').select()
             
             

             persons = db.table('person').where(name__eq='zhangsan').select('id', 'name', 'age')
             
             

             persons = db.query('select id, name, age from person')
             
             
             
             
             

             persons = db.sql('select id, name, age from person').query()
             
             
             
             
             

             persons = db.query_one('select id, name, age from person where name = ?', 'zhangsan')
             
             

             persons = db.sql('select id, name, age from person where name = ?').query_one('zhangsan')
             
             

             persons = db.query('select id, name, age from person where name = :name', name='zhangsan')
             
             

             persons = db.sql('select id, name, age from person where name = :name').query(name='zhangsan')
             
             

             persons = db.sql('select id, name, age from person where name = :name').param(name='zhangsan').query()
             
             

             persons = db.table('person').columns('id', 'name', 'age').where(name='zhangsan').query()
             
             

             effected_rowcount = db.table('person').where(name='zhangsan').update(name='xxx', age=45)

             effected_rowcount = db.table('person').where(id=6).delete()
             count = db.table('person').count())
             

             effected_rowcount = db.execute('delete from person where id = :id', id=5)
             count = db.get('select count(1) from person')
             

             effected_rowcount = db.sql('delete from person where id = ?').execute(4)
             count = db.sql('select count(1) from person').get()
             

             effected_rowcount = db.sql('delete from person where id = :id').execute(id=3)
             count = db.sql('select count(1) from person').get()
             

             
             db.sql('select name, age from person WHERE name = ?').load('张三').to_csv('test.csv')

             db.sql('select name, age from person WHERE name = ?').param('张三').to_csv('test.csv')

             
             db.table('person').insert_from_csv('test.csv')

             
             df = db.sql('select name, age from person WHERE name = :name').load(name='张三').to_df()

             df = db.sql('select name, age from person WHERE name = :name').param(name='张三').to_df()

             
             db.table('person').insert_from_df(dataframe)

             
             db.sql('select name, age from person WHERE name = ?').load('张三').to_json('test.json')

             db.sql('select name, age from person WHERE name = ?').param('张三').to_json('test.json')

             
             db.table('person').insert_from_json('test.json')

             db.close()

  Transaction
  '''''''''''

  .. code:: python

         from sqlexecx import trans

         @trans
         def test_transaction():
             insert_func(....)
             update_func(....)


         def test_transaction2():
             with trans():
                 insert_func(....)
                 update_func(....)

  If you want to use ORM, may be you need SQLORMX: https://pypi.org/project/sqlormx

  If you want to operate MySQL database like Mybatis, may be you need MySQLX: https://pypi.org/project/mysqlx

  If you want to operate PostgreSQL databaselike Mybatis, may be you need PgSQLX: https://pypi.org/project/pgsqlx

  If you wanted simultaneously support MySQL and PostgreSQL, may be you need BatisX: https://pypi.org/project/batisx


pkgId: 866f9a6cda7479b2c5f5659f927ddc35aa4ae0315aa9d1e3fb30f338a4f46427
name: python-SQLObject-help
arch: noarch
version: 3.11.0
epoch: 0
release: 1
summary: Development documents and examples for SQLObject
url: http://sqlobject.org/
rpm_license: LGPL
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-SQLObject-3.11.0-1.src.rpm
location_href: Packages/python-SQLObject-help-3.11.0-1.noarch.rpm
checksum_type: sha256
description:
  SQLObject is a popular *Object Relational Manager* for providing an
  object interface to your database, with tables as classes, rows as
  instances, and columns as attributes.

  SQLObject includes a Python-object-based query language that makes SQL
  more abstract, and provides substantial database independence for
  applications.

  Supports MySQL, PostgreSQL, SQLite, Firebird, Sybase, MSSQL and MaxDB (SAPDB).
  Python 2.7 or 3.4+ is required.

  For development see the projects at
  `SourceForge <https://sourceforge.net/projects/sqlobject/>`_
  and `GitHub <https://github.com/sqlobject>`_.

  .. image:: https://github.com/sqlobject/sqlobject/actions/workflows/run-tests.yaml/badge.svg?branch=github-actions
     :target: https://github.com/sqlobject/sqlobject/actions/workflows/run-tests.yaml


pkgId: 2992ca5ef6731898dd32bb4854f0b6a653edaa421995a0353de215413500b79f
name: python-SRTrain-help
arch: noarch
version: 2.6.0
epoch: 0
release: 1
summary: Development documents and examples for SRTrain
url: https://github.com/ryanking13/SRT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-SRTrain-2.6.0-1.src.rpm
location_href: Packages/python-SRTrain-help-2.6.0-1.noarch.rpm
checksum_type: sha256
description:
  ![github actions badge](https://github.com/ryanking13/SRT/workflows/Test/badge.svg)
  [![Downloads](https://pepy.tech/badge/srtrain)](https://pepy.tech/project/srtrain)
  [![Downloads](https://pepy.tech/badge/srtrain/month)](https://pepy.tech/project/srtrain)
  [![Documentation Status](https://readthedocs.org/projects/srtrain/badge/?version=latest)](https://srtrain.readthedocs.io/en/latest/?badge=latest)


  SRT(Super Rapid Train) application python wrapper

  With `SRTrain`, you **can**:

  - Search SRT train schedules.
  - Reserve SRT trains.
  - Find your reservations/tickets information.
  - Cancel reservations/tickets.

  while you **can't**:

  - Pay for a ticket.
  - Search or reserve non-SRT trains (KTX, ITX, ... ) (use [korail2](https://github.com/carpedm20/korail2) instead)

  This project was inspired from [korail2](https://github.com/carpedm20/korail2) of [carpedm20](https://github.com/carpedm20).



  ```
  pip install SRTrain
  ```

  ```python
  >>> from SRT import SRT
  >>> srt = SRT("010-1234-xxxx", YOUR_PASSWORD)

  >>> dep = '수서'
  >>> arr = '부산'
  >>> date = '20190930'
  >>> time = '144000'
  >>> trains = srt.search_train(dep, arr, date, time)
  >>> trains





  >>> reservation = srt.reserve(trains[1])
  >>> reservation

  ```



  See [documentation](https://srtrain.readthedocs.io/en/latest/).



  - [go-SRT](https://github.com/ryanking13/go-SRT): SRT golang wrapper

rpm_license:
  MIT License  Copyright (c) 2018 Gyeongjae Choi  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: 889ebf7df4591d0b8c71b4aadea4c3d278f864d5a61f1eaa0b733dc115ade27e
name: python-SWTurbPy-help
arch: noarch
version: 0.0.4
epoch: 0
release: 1
summary: Development documents and examples for SWTurbPy
url: https://github.com/huangzesen/SWTurbPy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-SWTurbPy-0.0.4-1.src.rpm
location_href: Packages/python-SWTurbPy-help-0.0.4-1.noarch.rpm
checksum_type: sha256
description:
  **Description**: Estimate the PSD using the Fourier transform for a 3-component signal.
  **Parameters**:
  - `x, y, z` (numpy.ndarray): Time series data for each component.
  - `dt` (float): Sampling time.
  - `norm` (str, optional): Normalization method for FFT. Options are `{'forward', 'backward', 'ortho'}`.
  **Returns**:
  - `freqs` (numpy.ndarray): Frequencies of the PSD.


pkgId: ea7e70623014c41827c7017c2794c0648a8d8f2359857b0d1cbd0d766f9a71fa
name: python-ScandEval-help
arch: noarch
version: 14.0.2
epoch: 0
release: 1
summary: Development documents and examples for ScandEval
url: https://pypi.org/project/ScandEval/
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ScandEval-14.0.2-1.src.rpm
location_href: Packages/python-ScandEval-help-14.0.2-1.noarch.rpm
checksum_type: sha256
description:
  <div align='center'>
  <img src="https://raw.githubusercontent.com/ScandEval/ScandEval/main/gfx/scandeval.png" width="517" height="217">
  </div>



  ______________________________________________________________________
  [![Documentation](https://img.shields.io/badge/docs-passing-green)](https://scandeval.com/ScandEval)
  [![PyPI Status](https://badge.fury.io/py/scandeval.svg)](https://pypi.org/project/scandeval/)
  [![First paper](https://img.shields.io/badge/arXiv-2304.00906-b31b1b.svg)](https://arxiv.org/abs/2304.00906)
  [![Second paper](https://img.shields.io/badge/arXiv-2406.13469-b31b1b.svg)](https://arxiv.org/abs/2406.13469)
  [![License](https://img.shields.io/github/license/ScandEval/ScandEval)](https://github.com/ScandEval/ScandEval/blob/main/LICENSE)
  [![LastCommit](https://img.shields.io/github/last-commit/ScandEval/ScandEval)](https://github.com/ScandEval/ScandEval/commits/main)
  [![Code Coverage](https://img.shields.io/badge/Coverage-65%25-yellow.svg)](https://github.com/ScandEval/ScandEval/tree/main/tests)
  [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.0-4baaaa.svg)](https://github.com/ScandEval/ScandEval/blob/main/CODE_OF_CONDUCT.md)




  - Dan Saattrup Nielsen ([@saattrupdan](https://github.com/saattrupdan),
    dan.nielsen@alexandra.dk)
  - Kenneth Enevoldsen ([@KennethEnevoldsen](https://github.com/KennethEnevoldsen),
    kenneth.enevoldsen@cas.au.dk)



  To install the package simply write the following command in your favorite terminal:
  ```
  $ pip install scandeval[all]
  ```

  This will install the ScandEval package with all extras. You can also install the
  minimal version by leaving out the `[all]`, in which case the package will let you know
  when an evaluation requires a certain extra dependency, and how you install it.



  The easiest way to benchmark pretrained models is via the command line interface. After
  having installed the package, you can benchmark your favorite model like so:
  ```
  $ scandeval --model <model-id>
  ```

  Here `model` is the HuggingFace model ID, which can be found on the [HuggingFace
  Hub](https://huggingface.co/models). By default this will benchmark the model on all
  the tasks available. If you want to benchmark on a particular task, then use the
  `--task` argument:
  ```
  $ scandeval --model <model-id> --task sentiment-classification
  ```

  We can also narrow down which languages we would like to benchmark on. This can be done
  by setting the `--language` argument. Here we thus benchmark the model on the Danish
  sentiment classification task:
  ```
  $ scandeval --model <model-id> --task sentiment-classification --language da
  ```

  Multiple models, datasets and/or languages can be specified by just attaching multiple
  arguments. Here is an example with two models:
  ```
  $ scandeval --model <model-id1> --model <model-id2>
  ```

  The specific model version/revision to use can also be added after the suffix '@':
  ```
  $ scandeval --model <model-id>@<commit>
  ```

  This can be a branch name, a tag name, or a commit id. It defaults to 'main' for latest.

  See all the arguments and options available for the `scandeval` command by typing
  ```
  $ scandeval --help
  ```


  In a script, the syntax is similar to the command line interface. You simply initialise
  an object of the `Benchmarker` class, and call this benchmark object with your favorite
  model:
  ```
  >>> from scandeval import Benchmarker
  >>> benchmark = Benchmarker()
  >>> benchmark(model="<model>")
  ```

  To benchmark on a specific task and/or language, you simply specify the `task` or
  `language` arguments, shown here with same example as above:
  ```
  >>> benchmark(model="<model>", task="sentiment-classification", language="da")
  ```

  If you want to benchmark a subset of all the models on the Hugging Face Hub, you can
  simply leave out the `model` argument. In this example, we're benchmarking all Danish
  models on the Danish sentiment classification task:
  ```
  >>> benchmark(task="sentiment-classification", language="da")
  ```


  A Dockerfile is provided in the repo, which can be downloaded and run, without needing
  to clone the repo and installing from source. This can be fetched programmatically by
  running the following:
  ```
  $ wget https://raw.githubusercontent.com/ScandEval/ScandEval/main/Dockerfile.cuda
  ```

  Next, to be able to build the Docker image, first ensure that the NVIDIA Container
  Toolkit is
  [installed](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html#installation)
  and
  [configured](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html#configuring-docker).
  Ensure that the the CUDA version stated at the top of the Dockerfile matches the CUDA
  version installed (which you can check using `nvidia-smi`). After that, we build the
  image as follows:
  ```
  $ docker build --pull -t scandeval -f Dockerfile.cuda .
  ```

  With the Docker image built, we can now evaluate any model as follows:
  ```
  $ docker run -e args="<scandeval-arguments>" --gpus 1 --name scandeval --rm scandeval
  ```

  Here `<scandeval-arguments>` consists of the arguments added to the `scandeval` CLI
  argument. This could for instance be `--model <model-id> --task
  sentiment-classification`.



  - Thanks to [OpenAI](https://openai.com/) for sponsoring OpenAI credits as part of their
    [Researcher Access Program](https://openai.com/form/researcher-access-program/).
  - Thanks to [UWV](https://www.uwv.nl/) and [KU
    Leuven](https://www.arts.kuleuven.be/ling/ccl) for sponsoring the Azure OpenAI
    credits used to evaluate GPT-4-turbo in Dutch.
  - Thanks to [Miðeind](https://mideind.is/english.html) for sponsoring the OpenAI
    credits used to evaluate GPT-4-turbo in Icelandic and Faroese.
  - Thanks to [CHC](https://chc.au.dk/) for sponsoring the OpenAI credits used to
    evaluate GPT-4-turbo in German.



  If you want to cite the framework then feel free to use this:

  ```
  @article{nielsen2024encoder,
    title={Encoder vs Decoder: Comparative Analysis of Encoder and Decoder Language Models on Multilingual NLU Tasks},
    author={Nielsen, Dan Saattrup and Enevoldsen, Kenneth and Schneider-Kamp, Peter},
    journal={arXiv preprint arXiv:2406.13469},
    year={2024}
  }
  @inproceedings{nielsen2023scandeval,
    author = {Nielsen, Dan Saattrup},
    booktitle = {Proceedings of the 24th Nordic Conference on Computational Linguistics (NoDaLiDa)},
    month = may,
    pages = {185--201},
    title = {{ScandEval: A Benchmark for Scandinavian Natural Language Processing}},
    year = {2023}
  }
  ```


  The image used in the logo has been created by the amazing [Scandinavia and the
  World](https://satwcomic.com/) team. Go check them out!

rpm_license:
  MIT License  Copyright (c) 2022-2024 Dan Saattrup Nielsen  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: 46cf2860a4100406b571e7f1e530fa206c74d7d5fc45b78893ca40bed27282b6
name: python-ScreenPro2
arch: noarch
version: 0.4.17
epoch: 0
release: 1
summary: Flexible analysis of high-content CRISPR screening
url: https://github.com/ArcInstitute/ScreenPro2
rpm_license: MIT License
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-ScreenPro2-0.4.17-1.src.rpm
location_href: Packages/python-ScreenPro2-0.4.17-1.noarch.rpm
checksum_type: sha256
description:
  [![website](https://img.shields.io/badge/website-live-brightgreen)](https://arcinstitute.org/tools/screenpro2)
  [![PyPI version](https://badge.fury.io/py/ScreenPro2.svg)](https://badge.fury.io/py/ScreenPro2)
  [![Documentation Status](https://readthedocs.org/projects/screenpro2/badge/?version=latest)](https://screenpro2.readthedocs.io/en/latest/?version=latest)
  [![Downloads](https://static.pepy.tech/badge/screenpro2)](https://pepy.tech/project/screenpro2)
  [![Downloads](https://static.pepy.tech/badge/screenpro2/month)](https://pepy.tech/project/screenpro2)
  [![CodeQL](https://github.com/ArcInstitute/ScreenPro2/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/ArcInstitute/ScreenPro2/actions/workflows/github-code-scanning/codeql)






  [**ReadTheDocs**](https://screenpro2.readthedocs.io) |
  [**PyPI**](https://pypi.org/project/ScreenPro2)

  ScreenPro2 enables perform flexible analysis on high-content CRISPR screening datasets. It has functionalities to process data from diverse CRISPR screen platforms and is designed to be modular to enable easy extension to custom CRISPR screen platforms or other commonly used platforms in addition to the ones currently implemented.

  ___
  <details>
    <summary>Background</summary>
    <br>

    Functional genomics field is evolving rapidly and many more CRISPR screen platforms are now developed. Therefore,
    it's important to have a standardized workflow to analyze the data from these screens. ScreenPro2 is provided to
    enable researchers to easily process and analyze data from CRISPR screens. Currently, you need to have a basic background in programming (especially Python) to use ScreenPro2.

    ScreenPro2 is conceptually similar to the [**ScreenProcessing**](https://github.com/mhorlbeck/ScreenProcessing) pipeline but **ScreenPro2** is designed to be more modular, flexible, and extensible. Common CRISPR screen methods that we have implemented here are illustrated in a recent review paper:

    > From: [A new era in functional genomics screens](https://www.nature.com/articles/s41576-021-00409-w)

    > Fig. 1: Common types of CRISPR screening modalities indicating advances in CRISPR methods.

    > <img width="1000" alt="image" src="https://github.com/GilbertLabUCSF/ScreenPro2/assets/53412130/a39400ad-b24f-4859-b6e7-b4d5f269119c">

  </details>

  ___


  ScreenPro2 is available on [PyPI](https://pypi.org/project/ScreenPro2/) and can be installed with pip:
  ```bash
  pip install ScreenPro2
  ```
  ___
  For the latest version (development version) install from GitHub:
  ```bash
  pip install git+https://github.com/ArcInstitute/ScreenPro2.git
  ```




  ScreenPro2 has a built-in command line interface (CLI). You can access the CLI by running the following command in your terminal:

  ```bash
  screenpro --help
  ```


  You can also use ScreenPro2 as a Python package. To use ScreenPro2 in your Python code, you can import it as follows:

  ```python
  import screenpro as scp
  ```



  Data analysis for CRISPR screens with NGS readouts can be broken down into three main steps:

  - [Step 1: FASTQ processing](#step-1-fastq-processing)
  - [Step 2: Phenotype calculation](#step-2-phenotype-calculation)
  - [Step 3: Data visualization](#step-3-data-visualization)



  The first step in analyzing CRISPR screens with deep sequencing readouts is to process the FASTQ files and generate counts for each guide RNA element in the library. ScreenPro2 has built-in functionalities to process FASTQ files and generate counts for different types of CRISPR screens platforms (see [Supported CRISPR Screen Platforms](#supported-crispr-screen-platforms)).

  <details>
    <summary>Command Line Interface (CLI)</summary>
    <br>
    ScreenPro2 has a built-in command line interface (CLI) to process FASTQ files and generate counts.

    ```bash
    screenpro guidecounter --help
    ```

    A draft code to process FASTQ files and generate counts for [CRISPRa/i-single-sgRNA-screens](#dcas9-crisprai-single-sgrna-screens) dataset:

    ```bash
    screenpro guidecounter
      --cas-type dCas9
      --single-guide-design
      -l <path-to-CRISPR-library-table>
      -p <path-to-fastq-directory>
      -s <sample-id-1>,<sample2-id>       # comma-separated list of sample ids, i.e. `<sample_id>.fastq.gz` for single sgRNA screens
      -o <output-directory>
      --write-count-matrix
    ```

    A draft code to process FASTQ files and generate counts for [CRISPRa/i-dual-sgRNA-screens](#dcas9-crisprai-dual-sgrna-screens) dataset:

    ```bash
    screenpro guidecounter
      --cas-type dCas9
      --dual-guide-design
      -l <path-to-CRISPR-library-table>
      -p <path-to-fastq-directory>
      -s <sample-id-1>,<sample2-id>       # comma-separated list of sample ids, i.e. `<sample_id>_R[1,2].fastq.gz` for dual sgRNA screens
      -o <output-directory>
      --write-count-matrix
    ```
    ___

  </details>

  <details>
    <summary>Python Package Usage</summary>
    <br>

    In addition to the CLI, ScreenPro2 has a built-in method to process FASTQ files and generate counts in Python.

    This method is implemented in the `ngs` module and relvent submodules.
    A minor novelty here has enabled processing single, dual, or multiple sgRNA
    CRISPR screens. Also, this approach can retain recombination events which can
    occur in dual or higher order sgRNA CRISPR screens.

    Currently, `GuideCounter` class from the `ngs` module can process FASTQ files and generate counts for standard
    CRISPR screens with [single](#dcas9-crisprai-single-sgrna-screens) or [dual](#dcas9-crisprai-dual-sgrna-screens)
    guide design.

    Here is a draft code to process FASTQ files and generate counts for an experiment with [CRISPRa/i-dual-sgRNA-screens](#dcas9-crisprai-dual-sgrna-screens):

    ```python
    
    counter = scp.GuideCounter(cas_type = 'cas9', library_type = 'single_guide_design')

    
    counter.load_library("<path-to-CRISPR-library-table>", sep = '\t', verbose = True, index_col=None)

    
    samples = []
    
    

    
    counter.get_counts_matrix(
        fastq_dir = '<path-to-fastq-directory>',
        samples = samples,
        verbose = True
    )
    ```

    Here is a draft code to process FASTQ files and generate counts for an experiment with [CRISPRa/i-dual-sgRNA-screens](#crispri-dual-sgrna-screens):


    ```python
    
    counter = scp.GuideCounter(cas_type = 'dCas9', library_type = 'dual_guide_design')

    
    counter.load_library("<path-to-CRISPR-library-table>", sep = '\t', verbose = True, index_col=None)

    
    samples = []
    
    

    
    counter.get_counts_matrix(
        fastq_dir = '<path-to-fastq-directory>',
        samples = samples,
        verbose = True
    )
    ```

    After this, you have `.counts_mat` calculated in the `GuideCounter` object.

    To proceed, you need to create an `AnnData` object from the counts matrix and metadata. You can use the following code to create an `AnnData` object:

    ```python
    adata = counter.build_counts_anndata()
    ```

    ___

  </details>

  <br>



  Once you have the counts, you can use ScreenPro2 `phenoscore` and `phenostats` modules to calculate the phenotype scores and statistics between screen arms.

  <details>
    <summary>Load Data</summary>
    <br>

    First, load your data into an `AnnData` object (see [anndata](https://anndata.readthedocs.io/en/latest/index.html) for more information).

    The `AnnData` object must have the following contents:
    - `adata.X` – counts matrix (samples x targets) where each value represents the sequencing count from NGS data.
    - `adata.obs` – a pandas dataframe of samples metadata including "condition" and "replicate" columns.
      - "condition": the condition for each sample in the experiment.
      - "replicate": the replicate number for each sample in the experiment.
    - `adata.var` – a pandas dataframe of targets in sgRNA library including "target" and "targetType" columns.
      - "target": the target for each entry in reference sgRNA library. For single sgRNA libraries, this column can be
        used to store gene names. For dual or multiple targeting sgRNA libraries, this column can be used to store gene pairs
        or any other relevant information about the target.
      - "targetType": the type of target for each entry in reference sgRNA library. Note that this column is used to
        distinguish between different types of sgRNAs in the library and negative control sgRNAs can be defined as `"targetType" == "negative_control"`.
        This is important for the phenotype calculation step.


    ScreenPro2 has a built-in class for different types of CRISPR screen assays. Currently, there is a class called `PooledScreens`
    that can be used to process data from pooled CRISPR screens. To create a `PooledScreens` object from an `AnnData` object,
    you can use the following example code:

    ```python
    import pandas as pd
    import anndata as ad
    from screenpro.assays import PooledScreens

    adata = ad.AnnData(
        X   = counts_df, # pandas dataframe of counts (samples x targets)
        obs = meta_df,   # pandas dataframe of samples metadata including "condition" and "replicate" columns
        var = target_df  # pandas dataframe of targets metadata including "target" and "targetType" columns
    )

    screen = PooledScreens(adata)
    ```

    <img width="600" alt="image" src="https://github.com/ArcInstitute/ScreenPro2/assets/53412130/bb38d119-8f24-44fa-98ab-7ef4457ef8d2">

    ___

  </details>

  <details>
    <summary>Run workflows</summary>
    <br>

    Once the screen object is created, you can use several available workflows to calculate the phenotype scores and statisitics by comparing each entry in reference sgRNA library between screen arms. Then, these scores and statistics are used to nominate hits.

    
    `.calculateDrugScreen` method can be used to calculate the enrichment of each gene between screen arms for a drug
    screen experiment. This method calculates `gamma`, `rho`, and `tau` scores for each gene and adds them to the
    `.phenotypes` attribute of the `PooledScreens` object.

    Here is an example for running the workflow on a [CRISPRi-dual-sgRNA-screens](#dcas9-crisprai-dual-sgrna-screens) dataset:

    ```python
    
    screen.calculateDrugScreen(
      t0='T0',
      untreated='DMSO',  # replace with the label for untreated condition
      treated='Drug',    # replace with the label for treated condition
      score_level='compare_reps'
    )
    ```
    ___
    For example, in a Decitabine CRISPRi drug screen (see Figure 1B-C in [this bioRxiv paper](https://www.biorxiv.org/content/10.1101/2022.12.14.518457v2.full)), each phenotype score represents a comparison between different arms of the screen and `rho` scores shows the main drug phenotype as illustrated here:
    <img width="800" alt="image" src="https://github.com/abearab/ScreenPro2/assets/53412130/b84b3e1f-e049-4da6-b63d-d4c72bc97cda">

    
    `.calculateFlowBasedScreen` method can be used to calculate the enrichment of each target between high bin vs. low bin
    of a flow cytometry-based screen experiment. This method calculates `PhenoScore` for each target and adds them to the
    `.phenotypes` attribute of the `PooledScreens` object.

    ```python
    
    screen.calculateFlowBasedScreen(
      low_bin='low_bin', high_bin='high_bin',
      score_level='compare_reps'
    )
    ```
    ___

  </details>

  <details>
    <summary>Benchmarking ScreenPro2 vs other CRISPR screen processing tools</summary>
    <br>

    Coming soon...

  </details>

    <!-- Benchmarking ScreenPro2 with other CRISPR screen analysis tools

    

    

    

    Not only does ScreenPro2 have more features than ScreenProcessing, but it is also more flexible. ScreenPro2 can process data from diverse CRISPR screen platforms and is designed to be modular to enable easy extension to custom CRISPR screen platforms or other commonly used platforms in addition to the ones currently implemented.

    

    Last but not least, ScreenPro2 runs faster than ScreenProcessing (thanks to [biobear](https://github.com/wheretrue/biobear)) for processing FASTQ files. -->


  <br>



  Once the phenotypes are calculated, you can extract and explore the results using the `.phenotypes` attribute of the `PooledScreens` object. Currently, there are very limited functionalities built-in to visualize the results, but we are working on adding more features to make it easier for users. However, you can easily extract the results and use other libraries like `seaborn` and `matplotlib` in Python or `ggplot2` in R to visualize the results.

  ___


  One of the main goals of ScreenPro2 is to make it easy to process data from commonly used CRISPR screen platforms.
  Also, it is designed to be modular to enable easy extension to custom CRISPR screen platforms or other commonly used
  platforms in addition to the ones currently implemented.

  ___
  Currently, ScreenPro2 has easy-to-use workflows for the following CRISPR screen platforms:

  [Horlbeck et al., _eLife_ (2016)](http://dx.doi.org/10.7554/eLife.19760)

  Horlbeck et al. developed a CRISPR interference (CRISPRi) and CRISPR activation (CRISPRa) screening platform that uses a single sgRNA within a single plasmid and then there are up to 10 sgRNAs per gene. The multiple sgRNAs per gene can be used to perfrom statistical comparisons in guide-level or gene-level between screen arms. [ScreenProcessing](https://github.com/mhorlbeck/ScreenProcessing) has been developed to process data from this type of screen. We reimplemented the same workflow in ScreenPro2 and it has all the necessary tools to process data from this type of screen.

  <!-- TODO: Add link to example / tutorial -->


  [Replogle et al., _eLife_ (2022)](https://elifesciences.org/articles/81856)

  Replogle et al. developed a CRISPR interference (CRISPRi) and CRISPR activation (CRISPRa) screening platform that uses two sgRNAs per gene within a single plasmid, and it has been used to perform genome-scale CRISPRi screens. ScreenPro2 has all the necessary tools to process data from this type of screen.

  <!-- TODO: Add link to example / tutorial -->

  <!-- ### multiCas12a CRISPRi screens -->


  ScreenPro2 is licensed under the terms of the MIT license (see [LICENSE](LICENSE) for more information) and developed
  by Abolfazl (Abe) Arab ([@abearab](https://github.com/abearab)) as a Research Associate in the Gilbert lab at UCSF and Arc Institute.


  If you use ScreenPro2 in your research, please cite the following paper.

    Coming soon...


pkgId: 473f12e16ecbbc62a495ceabecc5066f3a1e3e83fdfeddb9a0386d0a2fb023f4
name: python-Shelegia-Motta-2021-help
arch: noarch
version: 1.0.3
epoch: 0
release: 1
summary: Development documents and examples for Shelegia-Motta-2021
url: https://github.com/manuelbieri/shelegia_motta_2021
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Shelegia-Motta-2021-1.0.3-1.src.rpm
location_href: Packages/python-Shelegia-Motta-2021-help-1.0.3-1.noarch.rpm
checksum_type: sha256
description:
  This package implements the models of [Shelegia and Motta (2021)](https://github.com/manuelbieri/shelegia_motta_2021/blob/f48f46ad2a37e3686189f17650d0923a88c1ae0d/Shelegia%20and%20Motta%20(2021).pdf).

  ![GitHub](https://img.shields.io/github/license/manuelbieri/shelegia_motta_2021)
  ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/Shelegia-Motta-2021)
  ![GitHub repo size](https://img.shields.io/github/repo-size/manuelbieri/shelegia_motta_2021)
  ![GitHub last commit](https://img.shields.io/github/last-commit/manuelbieri/shelegia_motta_2021)
  ![CI](https://github.com/manuelbieri/shelegia_motta_2021/actions/workflows/ci.yml/badge.svg)
  ![CodeQL](https://github.com/manuelbieri/shelegia_motta_2021/actions/workflows/codeql.yml/badge.svg)
  ![GitHub Release Date](https://img.shields.io/github/release-date/manuelbieri/shelegia_motta_2021)
  ![PyPi](https://github.com/manuelbieri/shelegia_motta_2021/actions/workflows/python-publish.yml/badge.svg)
  ![PyPI](https://img.shields.io/pypi/v/Shelegia-Motta-2021)
  ![PyPI - Status](https://img.shields.io/pypi/status/Shelegia-Motta-2021)
  ![GitHub deployments](https://img.shields.io/github/deployments/manuelbieri/shelegia_motta_2021/github-pages?label=Documentation)
  [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/manuelbieri/shelegia_motta_2021/HEAD)


  Installation over [PyPI](https://pypi.org/project/Shelegia-Motta-2021/):
  ```
  pip install Shelegia-Motta-2021
  ```

  Or installation over [GitHub](https://github.com/manuelbieri/shelegia_motta_2021):
  ```
  pip install git+https://github.com/manuelbieri/shelegia_motta_2021.git
  ```



  The theory of the “kill zone” has become an increasingly prominent cause for concern among economists in recent times, especially with the rise of digital companies that have become monopolists in their sectors internationally. Companies like Facebook are continuously acquiring start-ups that may have a chance of competing with them in some way in the future. The sheer size and dominance of these companies combined with their aggression regarding the acquisition of competitors makes entering these markets as a direct competitor very unattractive at first glance. However, this issue is not as one-sided as that. This paper aims to rationalize the well-known “kill zone” argument by providing a simple model that explores how and when an incumbent firm may induce an entrant to choose a “non-aggressive” innovation path and enter with the goal of being acquired.

  The different models revealed that platform-owning incumbents react in diametrically opposing fashion to an entrant’s plans to develop a substitute to their platform and a complement. When a larger firm is dominating a certain sector and new firms are trying to enter this market, these firms may feel a hesitation to produce a direct competitor to the products of the incumbent, and they will veer more towards producing a compliment as the prospect of the incumbent copying or acquiring the entrant looms. This is the reason a “kill zone” may emerge. Interestingly, the possibility of an acquisition by the incumbent does not worsen the “kill zone” effect. In fact, it may even induce the entrant to develop a product that rivals the incumbent in the hope of being acquired as this can generate massive profits for the smaller entrant. Meanwhile, a two – sided market will not alter the “kill zone” significantly compared to the basic model. Only simultaneous choices of both parties will avoid the existence of a “kill zone” since the choice of the entrant cannot prevent the incumbent to copy the entrant.


  Since all models implement the Shelegia_Motta_2021.IModel.IModel - Interface, therefore all models provide the same functionality (public methods), even though the results may change substantially.

  For all models add the following import statement:
  ```python
  import Shelegia_Motta_2021.Models
  ```




  The base model of the project consists of two players: The incumbent, which sells the primary product,
  and a start-up otherwise known as the entrant which sells a complementary product to the incumbent.
  One way to visualize a real-world application of this model would be to think of the entrant as a product or service
  that can be accessed through the platform of the incumbent, like a plug in that can be accessed through Google or a game on Facebook.
  The aim of this model is to monitor the choice that the entrant has between developing a substitute to or
  another compliment to the incumbent. The second aim is to observe the choice of the incumbent of whether
  to copy the original complementary product of the entrant by creating a perfect substitute or not.
  Seeing as the entrant may not have enough assets to fund a second product, the incumbent copying its first product
  would inhibit the entrant’s ability to fund its projects. This report will illustrate how the incumbent has a strategic incentive to copy
  the entrant if it is planning to compete and that it would refrain from copying if the entrant plans to develop a compliment.
  The subsequent models included in this report will introduce additional factors but will all be based on the basic model.

  The equilibrium path arguably supports the “kill zone” argument: due to the risk of an exclusionary strategy by the incumbent,
  a potential entrant may prefer to avoid a market trajectory which would lead it to compete with the core product of a dominant incumbent
  and would choose to develop another complementary product instead.

  ```python
  base_model = Shelegia_Motta_2021.Models.BaseModel()
  ```



  Besides the parameters used in the paper (and in the BaseModel), this class will introduce the parameter $\beta$ in the models, called
  the bargaining power of the incumbent. $\beta$ describes how much of the profits from the complementary product of the entrant will go to the incumbent
  In the paper the default value $\beta=0.5$ is used to derive the results, which indicate an equal share of the profits.

  ```python
  bargaining_power_model = Shelegia_Motta_2021.Models.BargainingPowerModel()
  ```



  This model indicates that if the incumbent were not able to observe the entrant at the moment of choosing,
  the “kill zone” effect whereby the entrant stays away from the substitute in order to avoid being copied would not take place.
  Intuitively, in the game as we studied it so far, the only reason why the entrant is choosing a trajectory leading to another complement
  is that it anticipates that if it chose one leading to a substitute, the incumbent would copy, making it an inefficient strategy
  for entering the market. However, if the incumbent cannot observe the entrant’s choice of strategy, the entrant could not hope to strategically affect the decision
  of the incumbent. This would lead to the entrant having a host of new opportunities when entering the market makes the entrant competing with a large company much more attractive.

  Although there may be situations where the entrant could commit to some actions (product design or marketing choices)
  which signals that it will not become a rival, and it would have all the incentive to commit to do so,
  then the game would be like the sequential moves game analyzed in the basic model.
  Otherwise, the entrant will never choose a complement just to avoid copying, and it will enter the “kill zone”.

  ```python
  unobservable_model = Shelegia_Motta_2021.Models.UnobservableModel()
  ```



  In order to explore how acquisitions may modify the entrant’s and the incumbent’s strategic choices, we extend the base model
  in order to allow an acquisition to take place after the incumbent commits to copying the entrant’s original complementary product
  (between t=1 and t=2, see demo.ipynb "Timing of the game"). We assume that the incumbent and the entrant share the gains (if any) attained from the acquisition equally.

  The “kill zone” still appears as a possible equilibrium outcome, however for a more reduced region of the parameter space.
  The prospect of getting some acquisition gains does tend to increase the profits gained from developing a substitute to the primary product,
  and this explains why part of the “kill zone” region where a complement was chosen without the acquisition, the entrant will now choose a substitute instead.

  ```python
  acquisition_model = Shelegia_Motta_2021.Models.AcquisitionModel()
  ```


  An alternative formulation could be introduced in order to allow acquisitions to take place before the copying decision by the incumbent. The results are qualitatively like the results of the model which had the acquisition after the copying decision. In this alternative formulation of the game, copying would never occur along the equilibrium path. Indeed, there would be an additional source of gains from acquisition consisting of avoiding the fixed cost of copying.




  ```python

  import Shelegia_Motta_2021.Models



  model: Shelegia_Motta_2021.IModel.IModel = Shelegia_Motta_2021.Models.BaseModel()


  print(model)


  model.plot_payoffs()


  model.plot_incumbent_best_answers()


  model.plot_equilibrium()


  plt.show()
  ```

  A demonstration of the code can be found in [demo.html](demo.html) (output of [demo.ipynb](demo.ipynb), on small screens it may not be displayed correctly).



  | Package &emsp; | Version &emsp; | Annotation &emsp;                               |
  |:---------------|:--------------:|:------------------------------------------------|
  | matplotlib     |     3.9.2      | Always needed (includes numpy)                  |
  | jupyter        |     1.1.1      | Just for the demonstration in demo.ipynb        |
  | IPython        |     8.27.0     | Just for the demonstration in demo.ipynb        |
  | pdoc           |     14.7.0     | Only to generate the documentation from scratch |
  <br>
  Install the dependencies with the following command:

  ```bash
  pip install -r requirements.txt
  ```
  (Note: Make sure you are operating in the same directory as the `requirements.txt` is located.)

  These packages include all the needed imports for the functionality of this package.


  For further information about the project (structure) and the code, see [resources/dev_notes.md](https://github.com/manuelbieri/shelegia_motta_2021/blob/master/resources/dev_notes.md).



  Run the testsuite with the following command:

  ```bash
  python -m unittest Shelegia_Motta_2021_Test/*Test.py
  ```


  For the latest version of the documentation open [manuelbieri.github.io/shelegia_motta_2021](https://manuelbieri.github.io/shelegia_motta_2021/Shelegia_Motta_2021.html) in your browser or call:
  ```python
  import Shelegia_Motta_2021

  Shelegia_Motta_2021.docs()
  ```



  Generate api-documentation with the following command (note the use of `pdoc`):
  ```bash
  pdoc -o ./docs Shelegia_Motta_2021 --docformat "numpy" --math
  ```


pkgId: 3bea520124346bf7da76f978345db5303822f665ca3518ec0492af894b60f5c5
name: python-Shortners-help
arch: noarch
version: 1.1.6
epoch: 0
release: 1
summary: Development documents and examples for Shortners
url: https://github.com/Clinton-Abraham
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Shortners-1.1.6-1.src.rpm
location_href: Packages/python-Shortners-help-1.1.6-1.noarch.rpm
checksum_type: sha256
description:
  <p align="center">
      📦 <a href="https://pypi.org/project/shortners" style="text-decoration:none;">SHORTNERS</a>
  </p>

  <p align="center">
     <a href="https://telegram.me/clinton_abraham"><img src="https://img.shields.io/badge/𝑪𝒍𝒊𝒏𝒕𝒐𝒏 𝑨𝒃𝒓𝒂𝒉𝒂𝒎-30302f?style=flat&logo=telegram" alt="telegram badge"/></a>
     <a href="https://telegram.me/Space_x_bots"><img src="https://img.shields.io/badge/Sᴘᴀᴄᴇ ✗ ʙᴏᴛꜱ-30302f?style=flat&logo=telegram" alt="telegram badge"/></a>
     <a href="https://telegram.me/sources_codes"><img src="https://img.shields.io/badge/Sᴏᴜʀᴄᴇ ᴄᴏᴅᴇꜱ-30302f?style=flat&logo=telegram" alt="telegram badge"/></a>
  </p>


  ```bash
  pip install shortners
  ```

  <img src="https://user-images.githubusercontent.com/73097560/115834477-dbab4500-a447-11eb-908a-139a6edaec5c.gif">

  ```python

  import asyncio
  from Shortners import Shortner

  shortner_api = "a1cgsja52iey3j53mg"
  shortner_url = "https://modijiurl.com/api"
  contents_url = "https://github.com/Clinton-Abraham"

  core = Shortner(api=shortner_api, domain=shortner_url)

  async def test():
      o = await core.shortlink(contents_url)
      print(o)

  asyncio.run(test())

  ```

  <img src="https://user-images.githubusercontent.com/73097560/115834477-dbab4500-a447-11eb-908a-139a6edaec5c.gif">

  ```python

  import asyncio
  from Shortners import Shortner

  shortner_api = "a1cgsja52iey3j53mg"
  shortner_url = "https://xxxxxx.net/api"
  contents_url = "https://github.com/Clinton-Abraham"

  core = Shortner(api=shortner_api, domain=shortner_url)

  async def test():
      o = await core.clinton(contents_url)
      print(o)

  asyncio.run(test())

  ```

  <img src="https://user-images.githubusercontent.com/73097560/115834477-dbab4500-a447-11eb-908a-139a6edaec5c.gif">


pkgId: 77464463aa07565a209c7269a7408a236700e3ce2df531534c5bdacaabee64e5
name: python-Simple-Network-help
arch: noarch
version: 2.2.1
epoch: 0
release: 1
summary: Development documents and examples for Simple-Network
url: https://github.com/cloner174/Simple-Network
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Simple-Network-2.2.1-1.src.rpm
location_href: Packages/python-Simple-Network-help-2.2.1-1.noarch.rpm
checksum_type: sha256
description:
  ```bash
          pip install simple-network
  ```


  The Simple-Network Package is a powerful tool designed for the construction and visualization of complex, multilayer networks. With an emphasis on ease of use and flexibility, this package allows users to create intricate network structures and render them in stunning 3D using Python. The MultilayerNetwork class is designed to efficiently handle both directed and undirected graphs, support sparse representations for large graphs, and manage attributes for nodes and edges, including the capability to handle inter-layer edges.



      Initialization and Graph Representation:
          The constructor initializes an empty multilayer network with optional arguments to specify whether the graph is directed and whether it is large, impacting the internal storage strategy.
          Nodes and edges are stored in dictionaries, allowing for efficient access and manipulation. Nodes are stored per layer, and edges are stored either as adjacency matrices (for small graphs) or as sparse matrices (for large graphs), depending on the graph's size.

      Layer Management:
          Layers are dynamically managed, with the ability to add layers as needed. Each layer operates independently, with its own set of nodes and edges.

      Node and Edge Management:
          Nodes can be added to specific layers, ensuring that the network's structure remains flexible and adaptable to various scenarios.
          Edges can be added within layers or between layers (inter-layer edges), supporting both intra-layer and inter-layer interactions. This flexibility is crucial for accurately modeling complex systems where entities might interact in multiple, distinct contexts.

      Attribute Management:
          The class supports setting attributes for both nodes and edges. This feature is particularly useful for annotating nodes and edges with additional information, such as weights, types, or any domain-specific data required for analysis.

      Bulk Updates:
          Methods are provided for preparing, accumulating, and applying bulk updates to edges. This functionality is designed to optimize performance when applying a large number of updates by minimizing the overhead of individual operations.

      Degree Calculation:
          The class offers a method to calculate the degrees of nodes within a layer. This calculation is critical for understanding the structure and dynamics of the network, such as identifying key nodes based on their connectivity. The method is designed to efficiently handle both dense and sparse representations and offers parallel execution for large graphs, further enhancing performance.



  The design of the MultilayerNetwork class reflects a thoughtful consideration of the complexities involved in managing multilayer networks. By accommodating both dense and sparse graph representations, the class is scalable to networks of varying sizes, from small to very large graphs. Furthermore, the class's methods for managing layers, nodes, edges, and attributes provide a flexible framework that can be adapted to a wide range of applications, from social network analysis to biological network studies.




  MultilayerNetwork Analysis, is designed to perform a variety of analyses on multilayer networks. It is equipped with several methods, each tailored to analyze different aspects of a network, including its structure, connectivity, and evolution over time.

  Let's delve into the details of its functionalities and the algorithms employed:

  **Functional Overview**

  * Layerwise Degree Distribution:
          This function calculates the degree distribution for each layer within the network. It utilizes the degrees computed by self.network.calculate_layer_degrees(layer), normalizing them by the total number of nodes to get the distribution.

  * Aggregate Network:
          Aggregates all layers into a single-layer network by summing up the weights of inter-layer edges. This unified view is useful for analyses that require a holistic perspective of the multilayer network.

  * Community Detection:
          Employs spectral clustering on a specified layer to detect communities within that layer. This method is crucial for identifying groups of closely interconnected nodes, shedding light on the network's modular structure.

  * Global Efficiency:
          Calculates the global efficiency for a given layer, offering insights into the network's overall integration and the efficiency of information or resource transfer across it.

  * Connected Components:
          Counts the number of connected components within a specific layer. This metric helps understand the network's fragmentation or coherence.

  * Dynamic Changes Analysis:
          Analyzes the evolution of global efficiency across multiple network snapshots, allowing for the observation of changes in network connectivity over time.

  * Inter-Layer Connectivity Exploration:
          Investigates the patterns of connectivity between different network layers, quantifying the density of inter-layer connections and analyzing the distribution of their weights.

  **Centrality Measures**

  The implementation of centrality measures—degree, betweenness, and eigenvector centrality—is pivotal for understanding the roles and influences of nodes within the network:

  * Degree Centrality:
          Calculated directly from the adjacency matrix, reflecting the number of connections each node has.

  * Betweenness Centrality:
          Computed by identifying all shortest paths and counting how many times each node acts as a bridge along these paths. This measure highlights nodes that play crucial roles in facilitating communication within the network.

  * Eigenvector Centrality:
          Relies on the principal eigenvector of the adjacency matrix to identify influential nodes, not just those with many connections, but those linked to other highly connected nodes.

  **Algorithmic Details**

      The Betweenness Centrality calculation is particularly noteworthy. It utilizes the Floyd-Warshall algorithm via scipy.sparse.csgraph.shortest_path to find all shortest paths and then iterates through these paths to compute the centrality scores.

      Eigenvector Centrality employs the power iteration method or direct eigenvalue decomposition (depending on the matrix type) to find the principal eigenvector, which serves as the centrality measure.

  **Practical Implications**

  This class provides a robust toolkit for analyzing multilayer networks, accommodating a wide range of applications from social network analysis to studying biological networks or transportation systems. By offering insights into the structure, dynamics, and influential entities within the network, MultilayerNetworkAnalysis enables researchers and practitioners to unravel complex relational patterns, optimize connectivity, and identify key influencers or critical points within the network.


  This implementation of centrality measures with Scipy provides a deeper understanding of the underlying mathematics of network analysis. It illustrates the direct manipulation of adjacency matrices and the application of fundamental linear algebra and graph theory concepts, offering a robust foundation for custom network analysis tool development.



  The package is compatible with Python 3.x environments and requires the following libraries:

      NumPy
      Plotly



  First, install the required libraries using the following command:

  ```bash
  pip install numpy plotly
  ```


  To install the Simple-Network Package, ensure you have Python 3.x installed on your system. The package depends on NumPy and Plotly, which will be installed automatically if you don't have them already.

  ```bash
  pip install Simple-Network
  ```
  This package offers comprehensive tools for constructing and visualizing complex multilayer networks in a 3D space. It features two primary components: MultilayerNetwork, for creating the network structure, and Visualize, for rendering the network interactively in 3D.


  **Building a Multilayer Network**

  To start building a multilayer network, import the MultilayerNetwork class from the package:
  ```python
  from simpleN import MultilayerNetwork
  ```
  *Initialize the network*
  ```
  graph = MultilayerNetwork()
  ```
  *Adding Layers*

  ```python
  graph.add_layer(layer_name='Layer_1')

  graph.add_layer('Layer_1')

  ```
  *Adding Nodes*

  ```python
  graph.add_node(layer_name='Layer_1', node=1)
  graph.add_node(layer_name='Layer_1', node=4)

  graph.add_node(1, Layer_1')
  graph.add_node(4, 'Layer_1')

  ```
  *Adding Edges*
  ```python
  graph.add_edge(node1=1, node2=4, layer_name='Layer_1', weight=1)
  ```

  *Setting Node and Edge Attributes*
  ```python
  graph.set_node_attribute(node=1, attr_name='attr1', attr_value='value1')

  graph.set_edge_attribute(node1=1, node2=4, layer_name='Layer_1', attr_name='attr1', attr_value='value1')
  ```

  **Visualizing the Network**

  To visualize the network in 3D:

  ```python

  from visualize import Visualize


  my_visualizer = Visualize(network=graph)


  my_visualizer.show_graph(edge_visibility_threshold=0.1)
  ```
  Or Simple as :

  ```python
  Visualize(graph).show_graph()
  ```


  For basic usage examples, please refer to the Jupyter Notebook in the Examples folder.



  **Class: MultilayerNetwork**

  *Attributes:*

      directed (bool): Indicates whether the network edges are directed.
      node_count (int): Total number of unique nodes in the network.
      node (list): List of unique nodes.
      nodes (dict): Nodes organized by layer. Format: {layer_name: [nodes]}
      edges (dict): Edge weights organized by layer. Format: {layer_name: numpy_array}
      layers (list): List of layer names.
      node_attributes (dict): Node attributes. Format: {node: {attr_name: attr_value}}
      edge_attributes (dict): Edge attributes. Format: {(layer_name, node1, node2): {attr_name: attr_value}}
      inter_layer_edges (list): Edges between layers. Format: (node1, layer1, node2, layer2, weight)

  *Methods:*

      __init__(self, directed=False): Initializes a new network. Defaults to undirected.
      add_layer(self, layer_name): Adds a new layer. If it exists, does nothing.
      add_node(self, layer_name, node): Adds a node to a layer. Creates layer if non-existent.
      add_edge(self, node1, node2, layer_name, weight=1): Adds an edge within a layer. Initializes layer if needed.
      set_node_attribute(self, node, attr_name, attr_value): Sets an attribute for a node.
      set_edge_attribute(self, node1, node2, layer_name, attr_name, attr_value): Sets an attribute for an edge.
      add_inter_layer_edge(self, node1, layer1, node2, layer2, weight=1): Adds an edge between two different layers.
      Additional methods detailed in the documentation handle internal operations, node and edge validation, and network analysis functions such as calculating node degrees within layers.

  **Class: Visualize**

  The Visualize class enables interactive 3D visualization of networks using Plotly.

  *Methods:*

      show_graph(edge_visibility_threshold=0.1): Renders the network in 3D. Edges below the specified visibility threshold are not displayed.



  To err is human, and nobody likes a perfect person! If you come across any mistakes or if you have questions, feel free to raise an issue or submit a pull request. Your contributions to improving the content are highly appreciated. Please refer to GitHub contributing guidelines for more information on how to participate in the development.



  This project is licensed under the MIT License. For more details, see the LICENSE file in the project repository.



  email: cloner174.org@gmail.com

  other: https://t.me/PythonLearn0


pkgId: 7fb61b8c060e32adf3138c5e27e0654582a0d0316025c7efc2d5e0f11adc1bc3
name: python-SimpleBattle-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for SimpleBattle
url: https://github.com/ZefengPei/533project_step3
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-SimpleBattle-0.0.1-1.src.rpm
location_href: Packages/python-SimpleBattle-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  Defines the characters participating in the game, including both players and NPCs. Inheritance is used to share common behavior.

  - **`character.py`**
    - The base `Character` class provides shared properties and methods for all characters in the game.
    - **Functions:**
      - `__init__(name="Unnamed")`: Initializes a character with a name, random stats, and an empty inventory.
      - `generate_stats()`: Randomly assigns stats for a character:
        - **HP (Health Points):** Range 50-100.
        - **ATK (Attack Power):** Range 5-15.
        - **CRIT (Critical Hit Chance):** Range 10-30%.
        - **DODGE (Dodge Chance):** Range 10-30%.
      - `take_damage(damage)`: Reduces the character's HP by a specified damage value. Ensures HP does not fall below 0.
      - `dodge_attack(dodge_modifier)`: Determines if the character successfully dodges an incoming attack using their dodge stats and a modifier.
      - `critical_attack(crit_modifier)`: Determines if a critical hit occurs, doubling the damage dealt.
  - **`player.py`**
    - The `Player` class inherits from `Character` and represents the user-controlled player.
    - **Functions:**
      - `__init__()`: Initializes the player with default stats and an empty inventory.
      - `use_item(item)`: Applies the effect of an item to the player's stats. The item's effects are defined in a dictionary:
      - `choose_attack(player_input)`: Allows the player to select an attack type:
        - **Basic Attack:** Standard damage and dodge/crit chance.
        - **Heavy Strike:** High damage but easier to dodge.
        - **Quick Attack:** Lower damage but harder to dodge and higher crit chance.
  - **`npc.py`**
    - The `NPC` class inherits from `Character` and represents the non-playable opponents.
    - **Functions:**
      - `__init__()`: Initializes the NPC with a default name ("Enemy") and a random characteristic ("gentle", "rude", or "neutral").
      - `choose_attack()`: Randomly selects an attack type (Basic, Heavy, or Quick) and returns its details.


pkgId: c8c2add5a81013138ba3a862e146e06b74766e3c0748489e68116cb85d3f0497
name: python-SimpleDomControl-help
arch: noarch
version: 0.57.8
epoch: 0
release: 1
summary: Development documents and examples for SimpleDomControl
url: https://github.com/StarmanMartin/sdc
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-SimpleDomControl-0.57.8-1.src.rpm
location_href: Packages/python-SimpleDomControl-help-0.57.8-1.noarch.rpm
checksum_type: sha256
description:
  SDC is a framework that combines elements of both the MVC (Model-View-Controller) and MVT (Model-View-Template) patterns. Its main goal is to provide a tool for simple and efficient web development. The name ‘SDC’ is an abbreviation for ‘Simple DOM Control,’ indicating its focus on controlling and manipulating the Document Object Model (DOM), which is crucial for web development, particularly in dynamic web pages.

  For detailed docs go to [rtd](https://simpledomcontrol.readthedocs.io/en/latest/)


pkgId: cc53194e958962f0845eae6fed408e395f73a1a644f1e36b6b79223fce8462a0
name: python-SimpleFacturaSDK-help
arch: noarch
version: 1.1.8
epoch: 0
release: 1
summary: Development documents and examples for SimpleFacturaSDK
url: https://github.com/pereacarlos/SimpleFacturaSDK-python
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-SimpleFacturaSDK-1.1.8-1.src.rpm
location_href: Packages/python-SimpleFacturaSDK-help-1.1.8-1.noarch.rpm
checksum_type: sha256
description:
  - **Simplifica** la interacción con los servicios de SimpleFactura.
  - Proporciona interfaces específicas para operaciones como:
    - **Facturación**: Generación y gestión de documentos tributarios electrónicos.
    - **Gestión** de productos, proveedores y clientes.
    - **Gestión de folios**.
    - **Emisión de boletas de honorarios**.


pkgId: 3e0c6eaa9c69bca38ccb386616673ef80e75541e539a724f30938068196758c7
name: python-Simyan-help
arch: noarch
version: 1.4.0
epoch: 0
release: 1
summary: Development documents and examples for Simyan
url: https://pypi.org/project/Simyan
rpm_license: GPL-3.0-or-later
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Simyan-1.4.0-1.src.rpm
location_href: Packages/python-Simyan-help-1.4.0-1.noarch.rpm
checksum_type: sha256
description:
  [![PyPI - Python](https://img.shields.io/pypi/pyversions/Simyan.svg?logo=Python&label=Python&style=flat-square)](https://pypi.python.org/pypi/Simyan/)
  [![PyPI - Status](https://img.shields.io/pypi/status/Simyan.svg?logo=Python&label=Status&style=flat-square)](https://pypi.python.org/pypi/Simyan/)
  [![PyPI - Version](https://img.shields.io/pypi/v/Simyan.svg?logo=Python&label=Version&style=flat-square)](https://pypi.python.org/pypi/Simyan/)
  [![PyPI - License](https://img.shields.io/pypi/l/Simyan.svg?logo=Python&label=License&style=flat-square)](https://opensource.org/licenses/GPL-3.0)

  [![pre-commit](https://img.shields.io/badge/pre--commit-enabled-informational?logo=pre-commit&style=flat-square)](https://github.com/pre-commit/pre-commit)
  [![Ruff](https://img.shields.io/badge/ruff-enabled-informational?logo=ruff&style=flat-square)](https://github.com/astral-sh/ruff)

  [![Github - Contributors](https://img.shields.io/github/contributors/Metron-Project/Simyan.svg?logo=Github&label=Contributors&style=flat-square)](https://github.com/Metron-Project/Simyan/graphs/contributors)
  [![Github Action - Testing](https://img.shields.io/github/actions/workflow/status/Metron-Project/Simyan/testing.yaml?branch=main&logo=Github&label=Testing&style=flat-square)](https://github.com/Metron-Project/Simyan/actions/workflows/testing.yaml)
  [![Github Action - Publishing](https://img.shields.io/github/actions/workflow/status/Metron-Project/Simyan/publishing.yaml?branch=main&logo=Github&label=Publishing&style=flat-square)](https://github.com/Metron-Project/Simyan/actions/workflows/publishing.yaml)

  [![Read the Docs](https://img.shields.io/readthedocs/simyan?label=Read-the-Docs&logo=Read-the-Docs&style=flat-square)](https://simyan.readthedocs.io/en/stable)

  A [Python](https://www.python.org/) wrapper for the [Comicvine API](https://comicvine.gamespot.com/api/).



  ```console
  pip install --user Simyan
  ```



  ```python
  from simyan.comicvine import Comicvine
  from simyan.sqlite_cache import SQLiteCache

  session = Comicvine(api_key="Comicvine API Key", cache=SQLiteCache())


  results = session.list_publishers(params={"filter": "name:DC Comics"})
  for publisher in results:
      print(f"{publisher.id} | {publisher.name} - {publisher.site_url}")


  result = session.get_volume(volume_id=26266)
  print(result.summary)
  ```



  - [Simyan](https://simyan.readthedocs.io/en/stable)
  - [Comicvine API](https://comicvine.gamespot.com/api/documentation)



  Please use the [GitHub issue tracker](https://github.com/Metron-Project/Simyan/issues) to submit bugs or request features.



  - When running a new test for the first time, set the environment variable `COMICVINE__API_KEY` to your Comicvine API key.
    The responses will be cached in the `tests/cache.sqlite` database without your key.



  [![Social - Matrix](https://img.shields.io/matrix/metron-general:matrix.org?label=Metron%20General&logo=matrix&style=for-the-badge)](https://matrix.to/#/#metron-general:matrix.org)
  [![Social - Matrix](https://img.shields.io/matrix/metron-devel:matrix.org?label=Metron%20Development&logo=matrix&style=for-the-badge)](https://matrix.to/#/#metron-development:matrix.org)


pkgId: 38c8821ea8f6850ba112206f9d6d32d1a3b4244b1f18fa705bd8a0c51c89e474
name: python-SleePyPhases-help
arch: noarch
version: 0.1.4
epoch: 0
release: 1
summary: Development documents and examples for SleePyPhases
url: https://gitlab.com/sleep-is-all-you-need/sleepyphases
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-SleePyPhases-0.1.4-1.src.rpm
location_href: Packages/python-SleePyPhases-help-0.1.4-1.noarch.rpm
checksum_type: sha256
description:
  Machine learning based arousal detection during sleep. This project uses [pyPhases](https://pypi.org/project/pyPhases/).





  You need to download a valid dataset for example [SHHS](https://sleepdata.org/datasets/shhs) or [MESA](https://sleepdata.org/datasets/mesa).

  Supported dataset and their identifiers:

  - [SHHS](https://sleepdata.org/datasets/shhs): `shhs` (SHHS1)
  - [MESA](https://sleepdata.org/datasets/mesa): `mesa`
  - [MrOS](https://sleepdata.org/datasets/mros/): `mros`
  - TSM: `tsm` (local dataset from [Universitätsklinikum Carl Gustav Carus Dresden](https://www.uniklinikum-dresden.de/de))



  Depending on the dataset following config Values need to be specified: `shhs-path`, `mros-path`, `mesa-path`, `tsm-path`

  It is recommended to set up a file `userconfigs/local.yml` with following configuration values:

  ```yaml
  Extract:
    useMultiThreading: True  # "True" default value
    validatDataset: True  # "True" default value
  BuildDataset:
    useMultiThreading: True  # "True" default value

  shhs-path: D:/datasets/SHHS/
  mros-path: D:/datasets/MrOs/mros/
  mesa-path: D:/datasets/MESA/
  tsm-path: D:/datasets/TSM/records
  ```




  - Python >= `3.5`
  - [PyTorch](https://pytorch.org/get-started/locally/)
  - packages in `requirements.txt`: `pip install -r requirements.txt`



  There are default Configs in the folder `configs/datasets` for each dataset. The file `configs/datasets/[dataset identifier]/init.yaml` loads the default values to execute further commands.

  To test the Training process, you can execute the training only using few recordings:

  `phases run -c userconfigs/local.yaml,configs/datasets/shhs/init.yaml,configs/datasets/shhs/version-debug.yaml Training`

  If `phases` is not installed in your path you can use `python -m phases ...` instead.

  This command starts the extraction of the dataset and the training process.





  ```yaml
  version: "3.7"

  services:
    apptorch:
      image: registry.gitlab.com/tud.ibmt.public/pyphases/arousaldetector/torch
      entrypoint: python -m phases
      volumes:
        - ./data:/app/data
        - ./logs:/app/logs
        
        - ./datasets/:/app/datasets
        
        - ./userconfigs:/app/userconfigs
      
      deploy:
        resources:
          reservations:
            devices:
              - driver: nvidia
                device_ids: [ '0' ]
                capabilities: [ gpu ]
  ```
  Create a local config file in `userconfigs/local.yml` and add the following content:

  ```yaml
  useLoader: shhs
  shhs-path: /app/datasets/SHHS1
  ```

  Now you can test the project using docker compose:

  `docker compose run apptorch -c userconfigs/local.yml run Training`

  Run the complete Training:

  `docker compose run apptorch -c userconfigs/local.yml,configs/shhs.predefined.yaml run Training`







  ```yaml



  shhs-path: ./datasets/shhs
  useLoader: shhs

  dataversion:
    version: All
    groupBy: Null
    recordIds: Null


  export:
    annotations:
      - apnea
      - arousal
      - limb
      - sleepStage
      - light
    channels:
      - [EEG]
      - [EEG Ch2]
      - [EOG(L), EOG LOC-A2, E1-M2, "E1:M2"]
      - [EOG(R), EOG ROC-A1, "E2:M1"]
      - [EMG, EMG Chin, Chin1-Chin2, Chin]
      - [POSITION, Body]
      - [THOR RES, Effort THO, CHEST, RIP Thora]
      - [ABDO RES, Effort ABD, ABD, RIP Abdom]
      - [SaO2, SpO2]
      - [FLOW]

  ```



  `phases run --set recordId=shhs1-200001 -c config.yml Export`



  `phases run -c config.yml Export`










  make sure the right paths are set in `project.yaml` to use the dataset.

  `phases run -c configs/datasets/[DATASET]/init.yml run Training`

  for example:

  `phases run -c configs/datasets/mesa/init.yml run Training`






  Adding a new metric for the validation/evaluation you register a new metric using the Scorer class from `pyPhasesML`.

  ```python
  from pyPhasesML import Scorer

  class Setup(Phase):
      def prepareConfig(self):
          

          def scoreRecord(truth, prediction):
              
              return 1.0

          def scoreAllSamples(truth, prediction):
              
              return 1.0

          Scorer.registerMetric("score1", scoreRecord, scoreAllSamples)
  ```

  Update config:

  ```yaml


  trainingParameter:
    validationMetrics:
      - accuracy
      - score1


  eval:
    metrics:
    - kappa
    - score1
  ```



  `phases test test`

  Using docker: `docker compose run --rm phases-test test test -v`



  `docker compose run --rm --entrypoint bash phases-test`


  | Complete                           | Training with pyPhases                               |
  |------------------------------------|------------------------------------------------------|
  | ![Structure](assets/structure.svg) | ![PyPhases-Structure](assets/structure-pyPhases.svg) |




  Use all channels: `configs/datasets/shhs/channels.yaml`
  Change Classification: `configs/aasm-apnea.yaml`
  Use Hotencoding for model inputs: `configs/hotEncode.yaml`
  Change Model: `configs/models/apneaunet.yaml`

  Training: `phases run -c userconfigs/local.yml,configs/datasets/shhs/init.yaml,configs/datasets/shhs/version-debug.yaml,configs/datasets/shhs/channels.yaml,configs/aasm-apnea.yaml,configs/hotEncode.yaml,configs/models/apneaunet.yaml Training`


pkgId: 0071b82bc1f9c0e997a44228418c4feb55e666a72b2c81f4807fdabc9dd2d817
name: python-SmartBudget-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for SmartBudget
url: https://pypi.org/project/SmartBudget/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-SmartBudget-0.0.2-1.src.rpm
location_href: Packages/python-SmartBudget-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  SmartBudget - Бибилиотека для удобного управления финансами, анализом расходов и бюджетированием.



  ```python
  pip install SmartBudget


pkgId: cc0a7c40c28461444d694aadcadd55dfa1c8a7539e2decac60f747b0eb696e30
name: python-SolMuseum-help
arch: noarch
version: 0.1.3
epoch: 0
release: 1
summary: Development documents and examples for SolMuseum
url: https://github.com/smallbunnies/SolMuseum
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-SolMuseum-0.1.3-1.src.rpm
location_href: Packages/python-SolMuseum-help-0.1.3-1.noarch.rpm
checksum_type: sha256
description:
   This library encapsulates the common simulation models for
   Solverz-based simulation modelling. It is just required that one inputs the model parameters and then the simulation
   model instances are initialized without having to derive them symbolically and jit-compile the case-specified numerical
   codes, which saves the computation overhead.

  All the models that have been implemented can be found in the [docs](https://solmuseum.solverz.org) with mathematical
  derivations.



  SolMuseum requires ```python>=3.10```, and can be installed locally with

  ```shell
  pip install SolMuseum
  ```



  For example, we want to perform the finite difference of the heat pipe with the Yao's scheme. The illustrative code
  We can just import the `heat_pipe` class from `SolMuseum.pde`, input the parameters and set the method to be 'yao'.
  The finite difference equations are automatically derived and added to the `Model` instance.
  snippet is

  ```python
  import numpy as np
  from Solverz import Var, Param, Model
  from SolMuseum.pde import heat_pipe


  L = 9250
  dx = 370
  M = int(L / dx)
  Tinitial = np.zeros(M + 1)
  lam = 1 / 0.35
  Cp = 4182
  Ta = -10
  D = 1.4
  S = np.pi * (D / 2) ** 2
  rho = 960
  Tamb = -10

  for i in range(0, len(Tinitial)):
      fai = np.exp(-lam * i * dx / (Cp * np.abs(2543.5)))
      Tinitial[i] = 90.1724637976347 * fai + Ta * (1 - fai)

  m = Model()
  m.T = Var('T', Tinitial)
  m.m = Param('m', 10)
  m.lam = Param('lam', lam)
  m.rho = Param('rho', rho)
  m.S = Param('S', S)
  m.Tamb = Param('Tamb', Tamb)
  m.Cp = Param('Cp', Cp)
  m.dt = Param('dt', 180)
  m.__dict__.update(heat_pipe(m.T,
                              m.m,
                              m.lam,
                              m.rho,
                              m.Cp,
                              m.S,
                              m.Tamb,
                              dx,
                              m.dt,
                              M,
                              '1',
                              method='yao'))

  ```

  For reproducible codes of each model, please refer to the test folders, which can serve as the detailed tutorials.


pkgId: f73c077f3cca9f7619afaeaeac5235b50f864fe31a0542a747080f7f58d3839e
name: python-SpeedyAnnotate-help
arch: noarch
version: 1.0.8
epoch: 0
release: 1
summary: Development documents and examples for SpeedyAnnotate
url: https://gitlab.developers.cam.ac.uk/maths/cia/covid-19-projects/speedyannotate
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-SpeedyAnnotate-1.0.8-1.src.rpm
location_href: Packages/python-SpeedyAnnotate-help-1.0.8-1.noarch.rpm
checksum_type: sha256
description:
  SpeedyAnnotate is a straightforward and customisable annotation tool for images. It has three main modes:
  1. **[Data Labelling Mode](#data-labelling-mode)**: Annotate images with checkboxes and radiobuttons, with the option of adding bounding boxes.
  2. **[Conflict Resolution Mode](#conflict-resolution-mode)**: Resolve conflicts between two annotators by viewing only the images where
  there is a disagreement. Displays the annotations of both annotators and allows you to choose which to keep.
  3. **[Image Quality Assessment (IQA)](#image-quality-assessment-iqa)**: Helps you compare and evaluate image quality compared to a reference by
  showing the image to be assessed next to a reference image (i.e. full reference IQA). The criteria for
  assessment are customisable.
  The program may be run from the command line or as an executable, which can be downloaded or
  created from the source code (instructions below).
  Primarily developed for use on Mac OS X, but also compatible with Linux and Windows.
  > :warning: **Warning:** Please note that this application is still in development and there may be unresolved bugs and issues.
  > Use at your own risk!

  * [Installation](#installation)
  * [Usage](#usage)
  * [Data Labelling Mode](#data-labelling-mode)
  * [Conflict Resolution Mode](#conflict-resolution-mode)
  * [Image Quality Assessment (IQA)](#image-quality-assessment-iqa)
  * [Customisation](#customisation)
  * [YAML Files](#yaml-files)
  * [Backup Files](#backup-files)


pkgId: db561254a686601b5e9861c9fb1bb39f987ff2e9155892cf0acf557aeadcfb54
name: python-SpirentSLC-help
arch: noarch
version: 24.4.0
epoch: 0
release: 1
summary: Development documents and examples for SpirentSLC
url: https://pypi.org/project/SpirentSLC/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-SpirentSLC-24.4.0-1.src.rpm
location_href: Packages/python-SpirentSLC-help-24.4.0-1.noarch.rpm
checksum_type: sha256
description:
  The Spirent Session Control Library is used to control iTest sessions to enable quick and easy interaction with devices from a Python script. These target devices/APIs may be defined either on the fly, or via session profiles defined in iTest projects.



  The simplest way is as follows:

  * Download the latest Velocity Agent

  * Run it like this
      ./velocity-agent --agentVelocityHost localhost --sfAgentServerPort 9005 --listeningMode --sfAgentDisableSslValidation

  * Write python scripts using SLC
     Example script could be found and executed here:
      `python example.py`





  The Python Session Control Library is used to control iTest sessions to enable quick and easy interaction with devices from a Python script. These target devices/APIs may be defined either on the fly, or via session profiles defined in iTest projects.

  The library may operate in either one of these modes:

  * Standalone on a workstation
  * Connected to an iTest GUI instance





  Ensure that the following environment variables are set on the workstation that the library is installed on and that the script will run on:

  ```bash
    SPIRENT_SLC_HOST=local
    ITAR_PATH=path #to folder where iTars are placed
  ```

  It is also legal to not have the `SPIRENT_SLC_HOST` environment variable, in which case local is assumed.

  `ITAR_PATH` is set on the local environment to point to a folder where iTars and exploded project folders are placed, so that the local execution agent can find projects. It is not necessary to set this when connecting to a running instance of iTest GUI or Velocity.

  ```python
  from SpirentSLC import SLC
  slc = SLC.init()
  ```

  Once the library is imported, calling `SLC.init()` will initialize the underlying execution agent as a background process which the library will communicate with. An object is returned which is the entry point for further communication with the library. In this release only one `init()` call may be made within one Python interpreter context.

  An exception will be thrown if unable to initialize the library.



  Ensure that the following environment variables are set on the workstation that the library is installed on and that the script will run on:

  ```bash
  SPIRENT_SLC_HOST=localhost:port  # must be host and port of the configured instance of iTest GUI
  SPIRENT_SLC_PASSWORD=xxxx
  ```

  An instance of iTest must be running on the specified host and must be configured to accept connections at the desired port. A password may be optionally configured to restrict access to that instance, in which case the `SPIRENT_SLC_PASSWORD` environment variable must be specified, or provided in the init() call.

  ```python
  from SpirentSLC import SLC
  slc = SLC.init() # will take all values from environment variables
  ```

  alternatively values may be provided in the init() call:

  ```python
  slc = SLC.init(host='localhost:3030', password='xxx')
  ```

  An exception will be thrown if the library is unable to connect to the iTest GUI instance.



  By specification `SPIRENT_SLC_AGENT_PATH` environment variable pointing to iTest Agent folder it is possible to configure SLC to automatically start instance of new agent.

  ```bash
  SPIRENT_SLC_AGENT_PATH=path #to agent folder
  ITAR_PATH=path #to folder where iTars are placed
  ````

  ```python
  from SpirentSLC import SLC
  slc = SLC.init()
  ```



  Once initialized, the library will have access to all available iTest Projects.
  Each project contains a number of entities that can be addressed via code.
  These include Session Profiles, and Topologies.



  ```python
  slc.list()
  ==> ['topologies', 'session_profiles']
  ```

  All spaces in the name of a project or any other characters that are not legal in a Python identifier will be replaced by underscores in the returned values.



  Projects need to be imported first before being used. Since "import" is a reserved word in Python we will call it "open". This can be done via the following code:

  ```python
  proj = slc.open('project_name')
  ```

  Multiple projects can be imported if needed

  ```python
  sessions = slc.open('my_sessions')
  response_maps = slc.open('response_maps')
  ```



  * list all the usable topologies and session profiles in the project
    ```python
    proj.list()
    ==> ['dut1_ffsp', 'lab1_setup_tbml']
    ```
  * list other types of assets, such as parameter files and response maps
    ```python
    proj.list(parameter_file=True, response_map=True)
    ==> ['dut1_ffsp', 'lab1_setup_tbml', 'main_setup_ffpt', 'response_map1_ffrm']
    ```
  * show all QuickCalls available on a given session profile
    ```python
    proj.dut1_ffsp.list()
    ==> {
      'init_routes': {
        'all': 'True if all routes should be initialized'
      },
      'do_something_cool': {
        'param': 'Description of parameter'
      }
    }
    ```
  * access help on QuickCalls on a session attached to a resource in a topology
    ```python
    proj.lab1_setup_tbml.router1.ssh.list()
    ==> { ... same as above }
    ```

  * access the list of parameters for a specific QuickCall
    ```python
    proj.dut1_ffsp.list('init_routes')
    ==> { 'all': 'True if all routes should be initialized' }
    ```
    Built in session actions are not listed, only QuickCalls if a QuickCall library is attached to the session profile.

    If the user is accessing a built-in session type such as Telnet or SSH, they may still invoke the actions, but they will not be listed by the list() call.

    It should be noted that all displayed QuickCall names will by transformed into snake-case to conform to Python naming conventions.
    Working With Sessions

    

    Sessions are opened either directly on a session profile or local topology.
  * open session on a session profile
    ```python
    s1 = proj.dut1_ffsp.open()
    ```

  * open session, giving required parameters
    ```python
    s1 = proj.rest_session_ffsp.open(url='https://my_site.my_domain.com', accept_all_cookies=True)
    ```
  * open session, using parameter file
    ```python
    s1 = proj.rest_session_ffsp.open(parameter_file=proj.main_setup_ffpt)
    ```
  * open session, specify a response map to use
    ```python
    s1 = proj.rest_session_ffsp.open(response_map=proj.response_map1_ffrm)
    ```
  * open session, specify a reponse map library to use
    ```python
    s1 = proj.rest_session_ffsp.open(response_map_lib=resp_lib)
    ```
  * open session, specifying additional session properties
    ```python
    s1 = proj.rest_session_ffsp.open(properties={'authentication.authentication': 'Basic', 'authentication.user': 'me', 'authentication.password': 'totes_secret!'})
    ```
  * open session on a resource in a local topology
    ```python
    s1 = proj.lab1_setup_tbml.router1.ssh.open(...) # may use any combination of parameters, parameter_file, agent_requirements, properties
    ```



  It is possible to open a session directly without having a underlying session profile or topology file to start with.

  * open the native ssh session type directly, supplying required session profile information
    ```python
    s1 = slc.sessions.ssh.open(ip_address='10.20.30.40')
    ```
    Session Information
    Once a session is opened it is possible to find out some basic information about where the session is being handled. This is done via the agent property of a session object.
    ```python
    s1.agent
    ==> {
      'agent_type': 'local', # may be local, iTestGUI, or Velocity
      'name': 'agent_identifier',
      'capabilities': {...} # set of agent capabilities
    }
    ```



  An active session has a number of actions defined on it, which may be either built-in actions or QuickCalls defined on that session type. Any of those can be invoked on the session.

  * invoke the init_routes QuickCall with one parameter
    ```python
    response = s1.init_routes(all=True)
    ```
  * invoke a built-in action with a specific response map (which may override what was set for the session as a whole)
    ```python
    response = my_ssh_session.command('ls', response_map=proj.response_map_ls_ffrm)
    ```
    Response
    The resulting response object can be used to query details about the action execution as well as the response itself:
  * duration of execution and any error status
    ```python
    response.duration
    ==> 3 # number of seconds
    response.result
    ==> 'success' # may be success, failed, timeout
    ```

  * textual rendering of the response
    ```python
    response.text
    ==> 'textual response data'
    ```

  * if the response is json, it is easier to grab the json directly as a dictionary
    ```python
    response.json
    ==> instance of dictionary # null if not available as json
    ```

  * likewise if the response is xml it can be accessed directly as XML
    ```python
    response.xml
    ==> instance of xml.etree.ElementTree # null if not available as XML

    response.data
    ==> { dictionary of elements that exist in step structured data }
    ```



  The response object may also have queries defined on it - methods that query the structured data and return values. Queries may be auto-generated in iTest or be defined in response maps.

  * list the set of queries that exist for the response
    ```python
    response.queries()
    ==> [ 'is_empty()', 'counter_by_row(row)' ]
    ```

  * invoke query
    ```python
    response.counter_by_row(3)
    ==> 35
    ```
    Query names are always converted to snake case.



  Sessions should be closed when no longer needed, as they consume resources on the agent (and on Velocity if being used.) It is especially important to close sessions if sessions are being opened within a loop.

  * close session and free resources
    ```python
    s1.close()
    ```



  Proper shutdown of the library is important to ensure timely release of resources.

  * release all resources used by the library
    ```python
    slc.close()
    ```
    Resources released include all remaining open sessions, all reservations initiated by the script, and (if local) the underlying execution agent.


pkgId: 04117a4433e9d9fcd30cedcced2175ba015094ea1794af933f067c78d33541bc
name: python-Spring-Festival-help
arch: noarch
version: 2025.1
epoch: 0
release: 1
summary: Development documents and examples for Spring-Festival
url: https://github.com/QJZX/Spring_Festival
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Spring-Festival-2025.1-1.src.rpm
location_href: Packages/python-Spring-Festival-help-2025.1-1.noarch.rpm
checksum_type: sha256
description:
  > 2025春节彩蛋

  > 创意来源 [2025蛇年春晚Logo震撼发布](https://www.bilibili.com/video/BV12PqhYwEe3)



  ```
  pip install Spring-Festival
  ```



  ```
  import chunjie


  chunjie.watch_video()


  chunjie.watch_image()
  ```


pkgId: 3ba55e6807002a4d0aaee351aa9414f8fadcb5af0d09e681bc7313c3a1b9c69d
name: python-Stardew-Valley-Wiki-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for Stardew-Valley-Wiki
url: https://github.com/SkylarShao97/Stardew-Valley_Wiki
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Stardew-Valley-Wiki-0.0.1-1.src.rpm
location_href: Packages/python-Stardew-Valley-Wiki-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  ![passing build stamp](https://app.travis-ci.com/SkylarShao97/Stardew-Valley_Wiki.svg?token=ezeqdMKSGNT8hLvHZqTq&branch=main)

  The Stardew Wiki System Python project provides a console-based interface to interact with two main categories of information in the game **Stardew Valley**:
  - Living Things: Animals and crops in Stardew Valley.
  - Recipes: Recipes and their associated ingredients.
  The project is organized into subpackages (livingthings and recipes), each containing specific functionalities.

  ```
  stardew_wiki/
  ├── __init__.py          # Initializes the Stardew Wiki package
  ├── main.py              # Entry point for the entire package
  ├── livingthings/        # Subpackage for animals and crops
  │   ├── __init__.py
  │   ├── main.py
  │   ├── animals.py       # Animal-related functionality
  │   ├── crops.py         # Crop-related functionality
  │   ├── data/            # Data files for animals and crops
  │   │   ├── Animals.csv
  │   │   ├── Crops.csv
  ├── recipes/             # Subpackage for recipes and ingredients
  │   ├── __init__.py
  │   ├── main.py
  │   ├── recipe_search.py # Recipe search functionality
  │   ├── ingredient_search.py # Ingredient search functionality
  │   ├── data/            # Data files for recipes
  │   │   ├── wiki.xlsx


pkgId: ff1ffaa62c35c358a0f3aa6107acbe1c6a50a0381012b4f4403cd132b1a3d9b5
name: python-StreamingCommunity-help
arch: noarch
version: 1.9.5
epoch: 0
release: 1
summary: Development documents and examples for StreamingCommunity
url: https://github.com/Lovi-0/StreamingCommunity
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-StreamingCommunity-1.9.5-1.src.rpm
location_href: Packages/python-StreamingCommunity-help-1.9.5-1.noarch.rpm
checksum_type: sha256
description:
  ![Project Logo](https://i.ibb.co/f4h5Y2m/min-logo.png)

  A versatile script designed to download films and series from various supported streaming platforms.



  Chat, contribute, and have fun in our **Git_StreamingCommunity** Discord [Server](https://discord.com/invite/8vV68UGRc7)



  - [Website available](#website-status)
  - [Installation](#installation)
      - [PyPI Installation](#1-pypi-installation)
      - [Automatic Installation](#2-automatic-installation)
      - [Manual Installation](#3-manual-installation)
          - [Win 7](https://github.com/Ghost6446/StreamingCommunity_api/wiki/Installation#win-7)
          - [Termux](https://github.com/Ghost6446/StreamingCommunity_api/wiki/Termux)
  - [Configuration](#configuration)
      - [Default](#default-settings)
      - [Request](#requests-settings)
      - [Browser](#browser-settings)
      - [Download](#m3u8_download-settings)
      - [Parser](#m3u8_parser-settings)
  - [Docker](#docker)
  - [Tutorial](#tutorials)
  - [To Do](#to-do)
  - [Support](#support)
  - [Contribute](#contributing)
  - [Disclamer](#disclaimer)







  Install directly from PyPI:

  ```bash
  pip install StreamingCommunity
  ```



  Create `run_streaming.py`:

  ```python
  from StreamingCommunity.run import main

  if __name__ == "__main__":
      main()
  ```

  Run the script:
  ```bash
  python run_streaming.py
  ```



  ```bash
  pip install --upgrade StreamingCommunity
  ```





  | OS              | Automatic Installation Support |
  |:----------------|:------------------------------:|
  | Windows 10/11   |              ✔️              |
  | Windows 7       |              ❌              |
  | Debian Linux    |              ✔️              |
  | Arch Linux      |              ✔️              |
  | CentOS Stream 9 |              ✔️              |
  | FreeBSD         |              ⏳              |
  | MacOS           |              ✔️              |
  | Termux          |              ❌              |





  ```powershell
  .\win_install.bat
  ```



  ```bash
  sudo chmod +x unix_install.sh && ./unix_install.sh
  ```





  ```powershell
  python .\test_run.py
  ```

  or

  ```powershell
  source .venv/bin/activate && python test_run.py && deactivate
  ```



  ```bash
  ./test_run.py
  ```





  Prerequisites:
  * [Python](https://www.python.org/downloads/) > 3.8
  * [FFmpeg](https://www.gyan.dev/ffmpeg/builds/)



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





  ```powershell
  python test_run.py
  ```



  ```bash
  python3 test_run.py
  ```



  Keep your script up to date with the latest features by running:



  ```powershell
  python update.py
  ```



  ```bash
  python3 update.py
  ```

  <br>



  You can change some behaviors by tweaking the configuration file.

  The configuration file is divided into several main sections:



  ```json
  {
      "root_path": "Video",
      "movie_folder_name": "Movie",
      "serie_folder_name": "TV",
      "map_episode_name": "_SE_",
      "not_close": false,
      "show_trending": false
  }
  ```

  - `root_path`: Directory where all videos will be saved

    
    * Windows: `C:\\MyLibrary\\Folder` or `\\\\MyServer\\MyLibrary` (if you want to use a network folder)
    * Linux/MacOS: `Desktop/MyLibrary/Folder`
      `<br/><br/>`

  - `movie_folder_name`: The name of the subdirectory where movies will be stored.
  - `serie_folder_name`: The name of the subdirectory where TV series will be stored.

  - `map_episode_name`: Template for TV series episode filenames

    

    You can choose different vars:


    * `` : Is the name of TV Show
    * `` : Is the number of the season
    * `` : Is the number of the episode
    * `` : Is the name of the episode
      `<br/><br/>`

  - `not_close`: If true, continues running after downloading
  - `show_trending`: Display trending content on startup

      

      ```json
      {
          "config_qbit_tor": {
              "host": "192.168.1.59",
              "port": "8080",
              "user": "admin",
              "pass": "adminadmin"
          }
      }
      ```

      To enable qBittorrent integration, follow the setup guide [here](https://github.com/lgallard/qBittorrent-Controller/wiki/How-to-enable-the-qBittorrent-Web-UI).

  <br>



  ```json
  {
      "timeout": 20,
      "max_retry": 3
  }
  ```

  - `timeout`: Maximum timeout (in seconds) for each request
  - `max_retry`: Number of retry attempts per segment during M3U8 index download

  <br>



  ```json
  {
      "headless": false
  }
  ```

  - `headless`: Controls whether to run browser in headless mode

  <br>



  ```json
  {
      "tqdm_delay": 0.01,
      "tqdm_use_large_bar": true,
      "default_video_workser": 12,
      "default_audio_workser": 12,
      "cleanup_tmp_folder": true
  }
  ```

  - `tqdm_delay`: Delay between progress bar updates
  - `tqdm_use_large_bar`: Use detailed progress bar (recommended for desktop) set to false for mobile
  - `default_video_workser`: Number of threads for video download
  - `default_audio_workser`: Number of threads for audio download
  - `cleanup_tmp_folder`: Remove temporary .ts files after download


  <br>



  The following codes can be used for `specific_list_audio` and `specific_list_subtitles`:

  ```
  ara - Arabic       eng - English      ita - Italian     por - Portuguese
  baq - Basque       fil - Filipino     jpn - Japanese    rum - Romanian
  cat - Catalan      fin - Finnish      kan - Kannada     rus - Russian
  chi - Chinese      fre - French       kor - Korean      spa - Spanish
  cze - Czech        ger - German       mal - Malayalam   swe - Swedish
  dan - Danish       glg - Galician     may - Malay       tam - Tamil
  dut - Dutch        gre - Greek        nob - Norw. Bokm  tel - Telugu
                     heb - Hebrew       nor - Norwegian    tha - Thai
  forced-ita         hin - Hindi        pol - Polish      tur - Turkish
                     hun - Hungarian                       ukr - Ukrainian
                     ind - Indonesian                      vie - Vietnamese
  ```

  > [!IMPORTANT]
  > Language code availability may vary by site. Some platforms might:
  >
  > - Use different language codes
  > - Support only a subset of these languages
  > - Offer additional languages not listed here
  >
  > Check the specific site's available options if downloads fail.

  > [!TIP]
  > You can configure multiple languages by adding them to the lists:
  >
  > ```json
  > "specific_list_audio": ["ita", "eng", "spa"],
  > "specific_list_subtitles": ["ita", "eng", "spa"]
  > ```



  ```json
  {
      "force_resolution": -1,
      "get_only_link": false
  }
  ```

  - `force_resolution`: Force specific resolution (-1 for best available, or specify 1080, 720, 360)
  - `get_only_link`: Return M3U8 playlist/index URL instead of downloading

  <br>





  - Download a specific season by entering its number.
    *  **Example:** `1` will download *Season 1* only.

  -  Use the wildcard `*` to download every available season.
     * **Example:** `*` will download all seasons in the series.

  - Specify a range of seasons using a hyphen `-`.
     * **Example:** `1-2` will download *Seasons 1 and 2*.

  - Enter a season number followed by `-*` to download from that season to the end.
    * **Example:** `3-*` will download from *Season 3* to the final season.

  <br>



  You can run the script in a docker container, to build the image just run

  ```
  docker build -t streaming-community-api .
  ```

  and to run it use

  ```
  docker run -it -p 8000:8000 streaming-community-api
  ```

  By default the videos will be saved in `/app/Video` inside the container, if you want to to save them in your machine instead of the container just run

  ```
  docker run -it -p 8000:8000 -v /path/to/download:/app/Video streaming-community-api
  ```



  Inside the Makefile (install `make`) are already configured two commands to build and run the container:

  ```
  make build-container


  make LOCAL_DIR=/path/to/download run-container
  ```

  The `run-container` command mounts also the `config.json` file, so any change to the configuration file is reflected immediately without having to rebuild the image.



  | Website            | Status |
  |:-------------------|:------:|
  | 1337xx             |   ✅   |
  | Altadefinizione    |   ✅   |
  | AnimeUnity         |   ✅   |
  | Ilcorsaronero      |   ✅   |
  | CB01New            |   ✅   |
  | DDLStreamItaly     |   ✅   |
  | GuardaSerie        |   ✅   |
  | MostraGuarda       |   ✅   |
  | StreamingCommunity |   ✅   |



  - [Windows Tutorial](https://www.youtube.com/watch?v=mZGqK4wdN-k)
  - [Linux Tutorial](https://www.youtube.com/watch?v=0qUNXPE_mTg)
  - [Pypy Tutorial](https://www.youtube.com/watch?v=C6m9ZKOK0p4)
  - [Compiled .exe Tutorial](https://www.youtube.com/watch?v=pm4lqsxkTVo)



  - Create website API -> https://github.com/Lovi-0/StreamingCommunity/tree/test_gui_1



  If you'd like to support this project, consider making a donation!

  [![Donate](https://www.paypalobjects.com/en_US/i/btn/btn_donate_LG.gif)](https://www.paypal.com/donate/?hosted_button_id=UXTWMT8P6HE2C)



  Contributions are welcome! Steps:
  1. Fork the repository
  2. Create feature branch (`git checkout -b feature/AmazingFeature`)
  3. Commit changes (`git commit -m 'Add some AmazingFeature'`)
  4. Push to branch (`git push origin feature/AmazingFeature`)
  5. Open Pull Request




  This 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: c34c99a2798dae3c0e24ea0ad3114f8cfbbdee4defc7ad6a91e2eada2b323ed9
name: python-Subplot2Grid-help
arch: noarch
version: 0.0.1
epoch: 0
release: 1
summary: Development documents and examples for Subplot2Grid
url: https://github.com/ludvikalkhoury/Subplot2Grid.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Subplot2Grid-0.0.1-1.src.rpm
location_href: Packages/python-Subplot2Grid-help-0.0.1-1.noarch.rpm
checksum_type: sha256
description:
  Subplot2Grid is a tool that helps you design subplot layouts and generate corresponding code.


  To install this package, use:
  ``pip install Subplot2Grid``

  Then to run it, use:
  ``python -m Subplot2Grid``


  How to use:
  - Use the left mouse button to draw a rectangle on the canvas.
  - Use the right mouse button to delete a rectangle.
  - Use the middle mouse button to move and adjust the rectangle's placement.

  Features:
  - Generate and save the Python code for your layout.
  - Export a template image of the grid to remember labels and subplots.


pkgId: 46c7d4b6ab8ce0b5b1c4eb496dba4bf0625ae185d1c11b45dea31b81f7a22d32
name: python-SummarizeGPT-help
arch: noarch
version: 1.3
epoch: 0
release: 1
summary: Development documents and examples for SummarizeGPT
url: https://github.com/Maralai/SummarizeGPT
rpm_license: GPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-SummarizeGPT-1.3-1.src.rpm
location_href: Packages/python-SummarizeGPT-help-1.3-1.noarch.rpm
checksum_type: sha256
description:
  [![Test Summarize GPT](https://github.com/Maralai/SummarizeGPT/actions/workflows/python-app.yml/badge.svg)](https://github.com/Maralai/SummarizeGPT/actions/workflows/python-app.yml)
  [![Publish to PyPI](https://github.com/Maralai/SummarizeGPT/actions/workflows/publish.yml/badge.svg)](https://github.com/Maralai/SummarizeGPT/actions/workflows/publish.yml)


  This tool generates a summary of a directory's contents, including a tree view of its subdirectories and files, and the contents of each file. It can optionally exclude files listed in a .gitignore file, exclude or include Docker files, or filter files based on their extensions.


  This tool can be run directly from the command line without installation. Just ensure you have Python installed and can run Python scripts.
  Otherwise, you can install this tool as a package using pip:
  ```bash
  pip install summarizeGPT
  ```


  To use this tool, run the following command:
  ```
  SummarizeGPT <directory_path> [options]
  ```


  * `<directory_path>`: Path to the directory to summarize
  * `--gitignore <gitignore_path>`: Path to the gitignore file
  * `--include <file_extensions>`: Comma-separated list of file extensions to include
  * `--exclude <file_extensions>`: Comma-separated list of file extensions to exclude
  * `-d, --show_docker`: Include docker files
  * `-o, --show_only_docker`: Show only docker files
  * `-n, --max-lines <number>`: Maximum number of lines to include from each file
  * `--encoding {cl100k_base,p50k_base,r50k_base}`: Tiktoken encoding to use for token counting (default: cl100k_base)
  * `-v, --verbose`: Enable verbose output

  > Note: On Windows the command can be case insensitive (try 'summarizegpt'), but on Linux it must be 'SummarizeGPT'.


  Basic usage:
  ```bash
  SummarizeGPT .
  ```

  With gitignore:
  ```bash
  SummarizeGPT /path/to/directory --gitignore /path/to/.gitignore
  ```

  Filter by file extensions:
  ```bash
  SummarizeGPT /path/to/directory --include py,txt
  SummarizeGPT /path/to/directory --exclude xml,js
  ```

  Docker-related files:
  ```bash
  SummarizeGPT /path/to/directory -d  # Include Docker files
  SummarizeGPT /path/to/directory -o  # Show only Docker files
  ```

  Limit output and enable verbose logging:
  ```bash
  SummarizeGPT /path/to/directory -n 100 -v
  ```


  The tool generates a file called `Context_for_ChatGPT.md` in the specified directory containing:
  - A tree view of the directory structure
  - Contents of included files
  - Summary statistics including:
    - Total lines
    - Total characters
    - Total bytes
    - Approximate token count (using specified tiktoken encoding)


  - Does not interpret file contents
  - Does not handle symbolic links
  - Large directories or files can result in large output files
  - Token counting is approximate and depends on the chosen encoding


  - AI-powered code summarization to reduce output size and improve readability
  - Support for additional file types and encodings
  - Improved handling of large files and directories


  Contributions are welcome! Feel free to submit a pull request if you've made an improvement or fixed a bug.


  This project is licensed under the terms of the GPLv3 license.


pkgId: 0fbc1e853780364157e5e86d63068752d562e5636ed4a19c32696a8707831b58
name: python-Super-SCAD-Circle-Plus-help
arch: noarch
version: 0.9.9
epoch: 0
release: 1
summary: Development documents and examples for Super-SCAD-Circle-Plus
url: https://github.com/SuperSCAD/CirclePlus
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Super-SCAD-Circle-Plus-0.9.9-1.src.rpm
location_href: Packages/python-Super-SCAD-Circle-Plus-help-0.9.9-1.noarch.rpm
checksum_type: sha256
description:
  SuperSCAD widgets for circle sectors, circle segments, ellipses and ellipsoids.
  <table>
  <thead>
  <tr>
  <th>Legal</th>
  <th>Release</th>
  <th>Code</th>
  </tr>
  </thead>
  <tbody>
  <tr>
  <td>
  <a href="https://pypi.org/project/Super-SCAD-Circle-Plus/" target="_blank"><img alt="PyPI - License" src="https://img.shields.io/pypi/l/Super-SCAD-Circle-Plus">
  </a>
  </td>
  <td>
  <a href="https://badge.fury.io/py/Super-SCAD-Circle-Plus" target="_blank"><img src="https://badge.fury.io/py/Super-SCAD-Circle-Plus.svg" alt="Latest Stable Version"/></a><br/>
  </td>
  <td>
  <a href="https://codecov.io/gh/SuperSCAD/CirclePlus" target="_blank"><img src="https://codecov.io/gh/SuperSCAD/CirclePlus/graph/badge.svg?token=7D8V8RRY11" alt="Code Coverage"/></a>
  <a href="https://github.com/SuperSCAD/CirclePlus/actions/workflows/unit.yml"><img src="https://github.com/SuperSCAD/CirclePlus/actions/workflows/unit.yml/badge.svg" alt="unit Tests"/></a>
  </td>
  </tr>
  </tbody>
  </table>

  ![Demo.](/docs/images/demo.gif "Demo")



  This project is licensed under the terms of the [MIT license](LICENSE).


pkgId: f0a8605ad74fd3a71b0ed56c99651d9f26f952a7f33e15374ef75639b13937f6
name: python-Super-SCAD-Cone-help
arch: noarch
version: 0.10.1
epoch: 0
release: 1
summary: Development documents and examples for Super-SCAD-Cone
url: https://github.com/SuperSCAD/Cone
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Super-SCAD-Cone-0.10.1-1.src.rpm
location_href: Packages/python-Super-SCAD-Cone-help-0.10.1-1.noarch.rpm
checksum_type: sha256
description:
   SuperSCAD: Cone

  SuperSCAD widgets for cones and cylinders with smooth edges.

  <table>
  <thead>
  <tr>
  <th>Legal</th>
  <th>Release</th>
  <th>Code</th>
  </tr>
  </thead>
  <tbody>
  <tr>
  <td>
  <a href="https://pypi.org/project/Super-SCAD-Cone/" target="_blank"><img alt="PyPI - License" src="https://img.shields.io/pypi/l/Super-SCAD-Cone">
  </a>
  </td>
  <td>
  <a href="https://badge.fury.io/py/Super-SCAD-Cone" target="_blank"><img src="https://badge.fury.io/py/Super-SCAD-Cone.svg" alt="Latest Stable Version"/></a><br/>
  </td>
  <td>
  <a href="https://codecov.io/gh/SuperSCAD/Cone" target="_blank"><img src="https://codecov.io/gh/SuperSCAD/Cone/graph/badge.svg" alt="Code Coverage"/></a>
  <a href="https://github.com/SuperSCAD/Cone/actions/workflows/unit.yml"><img src="https://github.com/SuperSCAD/Cone/actions/workflows/unit.yml/badge.svg" alt="Unit Tests"/></a>
  </td>
  </tr>
  </tbody>
  </table>



  This project is licensed under the terms of the [MIT license](LICENSE).


pkgId: ec3913bb7e533934fdb2b6ab65b7534a9490e895f191428c04e8822a4a265bbe
name: python-Super-SCAD-Polygon-help
arch: noarch
version: 0.9.8
epoch: 0
release: 1
summary: Development documents and examples for Super-SCAD-Polygon
url: https://github.com/SuperSCAD/Polygon
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Super-SCAD-Polygon-0.9.8-1.src.rpm
location_href: Packages/python-Super-SCAD-Polygon-help-0.9.8-1.noarch.rpm
checksum_type: sha256
description:
  SuperSCAD widgets for polygons and smooth polygons.

  <table>
  <thead>
  <tr>
  <th>Legal</th>
  <th>Release</th>
  <th>Code</th>
  </tr>
  </thead>
  <tbody>
  <tr>
  <td>
  <a href="https://pypi.org/project/Super-SCAD-Polygon/" target="_blank"><img alt="PyPI - License" src="https://img.shields.io/pypi/l/Super-SCAD-Polygon">
  </a>
  </td>
  <td>
  <a href="https://badge.fury.io/py/Super-SCAD-Polygon" target="_blank"><img src="https://badge.fury.io/py/Super-SCAD-Polygon.svg" alt="Latest Stable Version"/></a><br/>
  </td>
  <td>
  <a href="https://codecov.io/gh/SuperSCAD/Polygon" target="_blank"><img src="https://codecov.io/gh/SuperSCAD/Polygon/graph/badge.svg" alt="Code Coverage"/></a>
  <a href="https://github.com/SuperSCAD/Polygon/actions/workflows/unit.yml"><img src="https://github.com/SuperSCAD/Polygon/actions/workflows/unit.yml/badge.svg" alt="unit Tests"/></a>
  </td>
  </tr>
  </tbody>
  </table>



  This project is licensed under the terms of the [MIT license](LICENSE).


pkgId: ccdb6e3c8a60ebfa9debfb06b00eb990b9c0276a06f9ea334b4d791ebf124bb0
name: python-Super-SCAD-Smooth-Profiles-help
arch: noarch
version: 0.6.2
epoch: 0
release: 1
summary: Development documents and examples for Super-SCAD-Smooth-Profiles
url: https://github.com/SuperSCAD/SmoothProfiles
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Super-SCAD-Smooth-Profiles-0.6.2-1.src.rpm
location_href: Packages/python-Super-SCAD-Smooth-Profiles-help-0.6.2-1.noarch.rpm
checksum_type: sha256
description:
  SuperSCAD widgets for chamfers, fillets, and other smooth profiles.

  <table>
  <thead>
  <tr>
  <th>Legal</th>
  <th>Release</th>
  <th>Code</th>
  </tr>
  </thead>
  <tbody>
  <tr>
  <td>
  <a href="https://pypi.org/project/Super-SCAD-Smooth-Profiles/" target="_blank"><img alt="PyPI - License" src="https://img.shields.io/pypi/l/Super-SCAD-Smooth-Profiles">
  </a>
  </td>
  <td>
  <a href="https://badge.fury.io/py/Super-SCAD-Smooth-Profiles" target="_blank"><img src="https://badge.fury.io/py/Super-SCAD-Smooth-Profiles.svg" alt="Latest Stable Version"/></a><br/>
  </td>
  <td>
  <a href="https://codecov.io/gh/SuperSCAD/SmoothProfiles" target="_blank"><img src="https://codecov.io/gh/SuperSCAD/SmoothProfiles/graph/badge.svg" alt="Code Coverage"/></a>
  <a href="https://github.com/SuperSCAD/SmoothProfiles/actions/workflows/unit.yml"><img src="https://github.com/SuperSCAD/SmoothProfiles/actions/workflows/unit.yml/badge.svg" alt="unit Tests"/></a>
  </td>
  </tr>
  </tbody>
  </table>



  This project is licensed under the terms of the [MIT license](LICENSE).


pkgId: aaa067db15b1b4916b000b73cd1b7cdfb4d9983f7f212393e57c52b2801fc9f6
name: python-Super-SCAD-Thread-help
arch: noarch
version: 0.2.0
epoch: 0
release: 1
summary: Development documents and examples for Super-SCAD-Thread
url: https://github.com/SuperSCAD/Thread
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Super-SCAD-Thread-0.2.0-1.src.rpm
location_href: Packages/python-Super-SCAD-Thread-help-0.2.0-1.noarch.rpm
checksum_type: sha256
description:
  SuperSCAD widgets for threads.

  <table>
  <thead>
  <tr>
  <th>Legal</th>
  <th>Release</th>
  <th>Code</th>
  </tr>
  </thead>
  <tbody>
  <tr>
  <td>
  <a href="https://pypi.org/project/Super-SCAD-Thread/" target="_blank"><img alt="PyPI - License" src="https://img.shields.io/pypi/l/Super-SCAD-Thread">
  </a>
  </td>
  <td>
  <a href="https://badge.fury.io/py/Super-SCAD-Thread" target="_blank"><img src="https://badge.fury.io/py/Super-SCAD-Thread.svg" alt="Latest Stable Version"/></a><br/>
  </td>
  <td>
  <a href="https://codecov.io/gh/SuperSCAD/Thread" target="_blank"><img src="https://codecov.io/gh/SuperSCAD/Thread/graph/badge.svg?token=7D8V8RRY11" alt="Code Coverage"/></a>
  <a href="https://github.com/SuperSCAD/Thread/actions/workflows/unit.yml"><img src="https://github.com/SuperSCAD/Thread/actions/workflows/unit.yml/badge.svg" alt="unit Tests"/></a>
  </td>
  </tr>
  </tbody>
  </table>



  This project is licensed under the terms of the [MIT license](LICENSE).


pkgId: 746633699e8718611177d348e595cf189c59aefdfbae4f55d3c8e2695b6563e1
name: python-Super-SCAD-help
arch: noarch
version: 0.10.4
epoch: 0
release: 1
summary: Development documents and examples for Super-SCAD
url: https://github.com/SuperSCAD/SuperSCAD
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Super-SCAD-0.10.4-1.src.rpm
location_href: Packages/python-Super-SCAD-help-0.10.4-1.noarch.rpm
checksum_type: sha256
description:
  <table>
  <thead>
  <tr>
  <th>Legal</th>
  <th>Docs</th>
  <th>Release</th>
  <th>Code</th>
  </tr>
  </thead>
  <tbody>
  <tr>
  <td>
  <a href="https://pypi.org/project/Super-SCAD/" target="_blank"><img alt="PyPI - License" src="https://img.shields.io/pypi/l/Super-SCAD"></a>
  </td>
  <td>
  <a href='https://superscad.readthedocs.io/en/latest/?badge=latest'> <img src='https://readthedocs.org/projects/superscad/badge/?version=latest' alt='Documentation Status'/></a>
  </td>
  <td>
  <a href="https://badge.fury.io/py/Super-SCAD" target="_blank"><img src="https://badge.fury.io/py/Super-SCAD.svg" alt="Latest Stable Version"/></a><br/>
  </td>
  <td>
  <a href="https://codecov.io/gh/SuperSCAD/SuperSCAD" target="_blank"><img src="https://codecov.io/gh/SuperSCAD/SuperSCAD/graph/badge.svg?token=7D8V8RRY11" alt="Code Coverage"/></a>
  <a href="https://github.com/SuperSCAD/SuperSCAD/actions/workflows/unit.yml"><img src="https://github.com/SuperSCAD/SuperSCAD/actions/workflows/unit.yml/badge.svg" alt="unit Tests"/></a>
  </td>
  </tr>
  </tbody>
  </table>



  SuperSCAD is an advanced application/library for generating 2D and 3D models in [OpenSCAD](https://openscad.org) in
  Python. SuperSCAD is based, among others, on the factory pattern and delivers to you as 2D and 3D modeler the
  superpowers of Python.



  The full documentation is available at https://superscad.readthedocs.io.



  We advise to create a Python virtual environment in a project folder:

  ```shell
  cd awsesome-project

  python -m venv .venv
  . .venv/bin/activate
  pip install super-scad
  ```

  Using your favorite editor, copy-paste the code from the demo in the next section and save the file under
  `openscad-logo.py`.

  ```shell
  vi openscad-logo.py
  ```

  Run python and open the generated `openscad-logo.scad` in openscad.

  ```shell
  python openscad-logo.py
  openscad openscad-logo.scad
  ```

  Congratulations, you just finished your first SuperSCAD project.



  Below is an example of SuperSCAD utilizing the factory pattern.

  ```python3
  from super_scad.boolean.Difference import Difference
  from super_scad.d3.Cylinder import Cylinder
  from super_scad.d3.Sphere import Sphere
  from super_scad.other.Modify import Modify
  from super_scad.scad.Context import Context
  from super_scad.scad.Scad import Scad
  from super_scad.scad.ScadWidget import ScadWidget
  from super_scad.scad.Unit import Unit
  from super_scad.transformation.Rotate3D import Rotate3D


  class Logo(ScadWidget):
      """
      SuperSCAD widget for generating OpenSCAD logo.
      """

      def build(self, context: Context):
          """
          Builds a SuperSCAD widget.

          :param context: The build context.
          """
          size: float = 50.0
          hole: float = size / 2.0
          height: float = 1.25 * size

          cylinder = Cylinder(height=height, diameter=hole, center=True, fn4n=True)
          sphere = Sphere(diameter=size, fn4n=True)

          return Difference(children=[sphere,
                                      cylinder,
                                      Modify(highlight=True, child=Rotate3D(angle_x=90.0, child=cylinder)),
                                      Rotate3D(angle_y=90.0, child=cylinder)])


  if __name__ == '__main__':
      scad = Scad(context=Context(fn=360))
      logo = Logo()
      scad.run_super_scad(logo, 'logo.scad')
  ```

  The example generates the logo of OpenSCAD.

  ![OpenSCAD Logo](openscad-logo.png)



  * [OpenSCAD SheetSheet](https://openscad.org/cheatsheet/index.html)



  This project is licensed under the terms of the [MIT license](LICENSE).


pkgId: d0fe9fd1d74ae418a8b3ea19618a90e9af2e865afce83767a10a0a245e8030b0
name: python-Supermarq-help
arch: noarch
version: 0.5.33
epoch: 0
release: 1
summary: Development documents and examples for Supermarq
url: https://pypi.org/project/Supermarq/
rpm_license: Apache-2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Supermarq-0.5.33-1.src.rpm
location_href: Packages/python-Supermarq-help-0.5.33-1.noarch.rpm
checksum_type: sha256
description:
  ![Continuous Integration](https://github.com/Infleqtion/client-superstaq/actions/workflows/ci.yml/badge.svg)

  [Supermarq](https://arxiv.org/abs/2202.11045) is a suite of application-oriented benchmarks used to measure the performance of quantum computing systems.

  The Supermarq package is available via `pip` and can be installed in your current Python environment with the command:
  ```
  pip install supermarq
  ```

  This is required if you intend to run checks locally
  ```
  pip install .[dev]
  ```

  The benchmarks are defined as classes within `supermarq/benchmarks/`. Each application
  defines two methods; `circuit` and `score`. These methods are used to generate the benchmarking circuit and evaluate its performance
  after execution on hardware.
  The quantum benchmarks within Supermarq are designed to be scalable, meaning that the benchmarks can be
  instantiated and generated for a wide range of circuit sizes and depths.
  The [Supermarq tutorial](https://github.com/Infleqtion/client-superstaq/tree/main/supermarq-benchmarks/examples) notebooks contain an end-to-end example of how to execute the GHZ benchmark
  using [Superstaq](https://superstaq.infleqtion.com/). The general workflow is as follows:
  ```python
  import supermarq
  ghz = supermarq.benchmarks.ghz.GHZ(num_qubits=3)
  ghz_circuit = ghz.circuit()
  counts = execute_circuit_on_quantum_hardware(ghz_circuit) # For example, via AWS Braket, IBM Qiskit, or Superstaq
  score = ghz.score(counts)
  ```


pkgId: 86745cb47405c684ada2d41ade38e0f048d68e4861f4c2fbc0ca6e05f7c4a162
name: python-Supysonic-help
arch: noarch
version: 0.7.9
epoch: 0
release: 1
summary: Development documents and examples for Supysonic
url: https://supysonic.readthedocs.io
rpm_license: GNU AGPLv3
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Supysonic-0.7.9-1.src.rpm
location_href: Packages/python-Supysonic-help-0.7.9-1.noarch.rpm
checksum_type: sha256
description:
  Supysonic is a Python implementation of the [Subsonic][] server API.

  Current supported features are:
  * browsing (by folders or tags)
  * streaming of various audio file formats
  * transcoding
  * user or random playlists
  * cover art
  * starred tracks/albums and ratings
  * [Last.FM][lastfm] scrobbling
  * Jukebox mode

  Supysonic currently targets the version 1.10.2 of the Subsonic API. For more
  details, go check the [API implementation status][docs-api].

  [subsonic]: http://www.subsonic.org/
  [lastfm]: https://www.last.fm/
  [docs-api]: https://supysonic.readthedocs.io/en/latest/api.html


pkgId: ffda7b25cb4f831497a2e641605c971eba372809979eb0d3768488017ba0a61c
name: python-SynthOpt-help
arch: noarch
version: 0.1.44
epoch: 0
release: 1
summary: Development documents and examples for SynthOpt
url: https://github.com/LewisHotchkissDPUK/SynthOpt
rpm_license: Apache License 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-SynthOpt-0.1.44-1.src.rpm
location_href: Packages/python-SynthOpt-help-0.1.44-1.noarch.rpm
checksum_type: sha256
description:
  Here is a link to the documentation for this package:
  [SynthOpt Documentation](https://lewishotchkiss.gitbook.io/synthopt "SynthOpt Documentation")


pkgId: 756a66905b315b5a7325842d9790f00ce017f72a228f2bef3c86fb3fb22823ab
name: python-SynthVal-help
arch: noarch
version: 0.1.4a0
epoch: 0
release: 1
summary: Development documents and examples for SynthVal
url: https://github.com/AIMet-Lab/SynthVal
rpm_license: GNU General Public License with Commons Clause License Condition v1.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-SynthVal-0.1.4a0-1.src.rpm
location_href: Packages/python-SynthVal-help-0.1.4a0-1.noarch.rpm
checksum_type: sha256
description:
  **SynthVal** is a Python package developed to validate and verify the quality of synthetically generated data by comparing it to original data. The project focuses primarily on medical images, such as chest x-rays and mammographies, offering tools to compute similarity measures between original and synthetic datasets.


pkgId: 0a52ce78067c240e795d298dfb68669dbe7d208c3dd591bf46149f12ffc8835f
name: python-TDCRPy-help
arch: noarch
version: 2.1.0
epoch: 0
release: 1
summary: Development documents and examples for TDCRPy
url: https://pypi.org/project/TDCRPy/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-TDCRPy-2.1.0-1.src.rpm
location_href: Packages/python-TDCRPy-help-2.1.0-1.noarch.rpm
checksum_type: sha256
description:
  `TDCRPy` is a Python code to estimate detection efficiencies of liquid scintillation counters (TDCR or CIEMAT/NIST).
  The calculation is based on a photo-physical stochastic model allowing to adress complexe decay schemes and radionuclide mixtures.

  The code is developped and maintained by the BIPM (MIT license).

  Technical details can be found in

  http://dx.doi.org/10.13140/RG.2.2.15682.80321



  `TDCRPy` requires that the following packages are installed in your `Python` environement.

  ```shell
  pip install importlib.resources configparser numpy tqdm setuptools scipy
  ```
  or in `conda` environement:

  ```shell
  conda install importlib.resources configparser numpy tqdm setuptools scipy
  ```

  Then, `TDCRPy` can be installed.

  ```shell
  pip install TDCRPy
  ```

  To obtain the last version.

  ```shell
  pip install TDCRPy --upgrade
  ```

  The module can be imported in your Python code such as.

  ```python
  import tdcrpy
  ```



  To run the unit tests of the package:

  ```shell
  python -m unittest tdcrpy.test.test_tdcrpy
  ```

  or (using the coverage package)

  ```shell
  coverage run -m unittest tdcrpy.test.test_tdcrpy
  coverage report -m
  ```



  ```python
  import tdcrpy
  ```






  ```python
  mode = "eff"               # ask for efficiency calculation
  L = 1.2                    # free parameter in keV-1
  Rad="Co-60"                # radionuclide
  pmf_1="1"                  # relative fraction of the radionulide
  N = 1000                   # number of Monte Carlo trials
  kB =1.0e-5                 # Birks constant in cm keV-1
  V = 10                     # volume of scintillator in mL
  ```


  ```python
  result = tdcrpy.TDCRPy.TDCRPy(L, Rad, pmf_1, N, kB, V, mode)
  ```


  ```python
  print(f"efficiency S = {round(result[0],4)} +/- {round(result[1],4)}")
  print(f"efficiency D = {round(result[2],4)} +/- {round(result[3],4)}")
  print(f"efficiency T = {round(result[4],4)} +/- {round(result[5],4)}")
  print(f"efficiency D (C/N system) = {round(result[12],4)} +/- {round(result[13],4)}")
  ```

      efficiency S = 0.9859 +/- 0.0031
      efficiency D = 0.9738 +/- 0.0043
      efficiency T = 0.9527 +/- 0.0057
      efficiency D (C/N system) = 0.9702 +/- 0.0045





  ```python
  TD = 0.977667386529166     # TDCR parameter
  ```


  ```python
  result = tdcrpy.TDCRPy.eff(TD, Rad, pmf_1, kB, V)
  ```

      global free parameter = 1.1991314352332345 keV-1



  ```python
  print(f"free parameter = {round(result[0],4)} keV-1")
  print(f"efficiency S = {round(result[2],4)} +/- {round(result[3],4)}")
  print(f"efficiency D = {round(result[4],4)} +/- {round(result[5],4)}")
  print(f"efficiency T = {round(result[6],4)} +/- {round(result[7],4)}")
  print(f"efficiency D (C/N system) = {round(result[14],4)} +/- {round(result[15],4)}")
  ```

      free parameter = 1.1991 keV-1
      efficiency S = 0.9858 +/- 0.001
      efficiency D = 0.973 +/- 0.0014
      efficiency T = 0.9512 +/- 0.0018
      efficiency D (C/N system) = 0.9692 +/- 0.0014







  ```python
  mode = "eff"               # ask for efficiency calculation
  L = (1.1, 1.3, 1.2)        # free parameter in keV-1
  Rad="Co-60"                # radionuclide
  pmf_1="1"                  # relative fraction of the radionulide
  N = 1000                   # number of Monte Carlo trials
  kB =1.0e-5                 # Birks constant in cm keV-1
  V = 10                     # volume of scintillator in mL
  ```


  ```python
  result = tdcrpy.TDCRPy.TDCRPy(L, Rad, pmf_1, N, kB, V)
  ```


  ```python
  print(f"efficiency S = {round(result[0],4)} +/- {round(result[1],4)}")
  print(f"efficiency D = {round(result[2],4)} +/- {round(result[3],4)}")
  print(f"efficiency T = {round(result[4],4)} +/- {round(result[5],4)}")
  print(f"efficiency AB = {round(result[6],4)} +/- {round(result[7],4)}")
  print(f"efficiency BC = {round(result[8],4)} +/- {round(result[9],4)}")
  print(f"efficiency AC = {round(result[10],4)} +/- {round(result[11],4)}")
  print(f"efficiency D (C/N system) = {round(result[12],4)} +/- {round(result[13],4)}")
  ```

      efficiency S = 0.9904 +/- 0.0024
      efficiency D = 0.9803 +/- 0.0037
      efficiency T = 0.9625 +/- 0.005
      efficiency AB = 0.9684 +/- 0.0045
      efficiency BC = 0.9696 +/- 0.0044
      efficiency AC = 0.9674 +/- 0.0046
      efficiency D (C/N system) = 0.9772 +/- 0.0039





  ```python
  TD = [0.977667386529166, 0.992232838598821, 0.992343419459002, 0.99275350064608]
  ```


  ```python
  result = tdcrpy.TDCRPy.eff(TD, Rad, pmf_1, kB, V)
  ```

      global free parameter = 1.2369501044018718 keV-1
      free parameters = [1.2369501 1.2369501 1.2369501] keV-1



  ```python
  print(f"Global free parameter = {round(result[0],4)} keV-1")
  print(f"free parameter of PMT A = {round(result[1][0],4)} keV-1")
  print(f"free parameter of PMT B = {round(result[1][1],4)} keV-1")
  print(f"free parameter of PMT C = {round(result[1][2],4)} keV-1")
  print(f"efficiency S = {round(result[2],4)} +/- {round(result[3],4)}")
  print(f"efficiency D = {round(result[4],4)} +/- {round(result[5],4)}")
  print(f"efficiency T = {round(result[6],4)} +/- {round(result[7],4)}")
  print(f"efficiency AB = {round(result[8],4)} +/- {round(result[9],4)}")
  print(f"efficiency BC = {round(result[10],4)} +/- {round(result[11],4)}")
  print(f"efficiency AC = {round(result[12],4)} +/- {round(result[13],4)}")
  print(f"efficiency D (C/N system) = {round(result[14],4)} +/- {round(result[15],4)}")
  ```

      Global free parameter = 1.237 keV-1
      free parameter of PMT A = 1.237 keV-1
      free parameter of PMT B = 1.237 keV-1
      free parameter of PMT C = 1.237 keV-1
      efficiency S = 0.9872 +/- 0.0009
      efficiency D = 0.9751 +/- 0.0013
      efficiency T = 0.9533 +/- 0.0018
      efficiency AB = 0.9606 +/- 0.0016
      efficiency BC = 0.9606 +/- 0.0016
      efficiency AC = 0.9606 +/- 0.0016
      efficiency D (C/N system) = 0.9714 +/- 0.0014







  ```python
  mode = "eff"               # ask for efficiency calculation
  mode2 = "sym"              # specify that symmetric PMTs is considered
  L = 1.2                    # free parameter in keV-1
  Rad="Co-60, H-3"           # radionuclides
  pmf_1="0.8, 0.2"                  # relatives fractions of the radionulides
  N = 1000                   # number of Monte Carlo trials
  kB =1.0e-5                 # Birks constant in cm keV-1
  V = 10                     # volume of scintillator in mL
  ```


  ```python
  result = tdcrpy.TDCRPy.TDCRPy(L, Rad, pmf_1, N, kB, V)
  ```


  ```python
  print(f"efficiency S = {round(result[0],4)} +/- {round(result[1],4)}")
  print(f"efficiency D = {round(result[2],4)} +/- {round(result[3],4)}")
  print(f"efficiency T = {round(result[4],4)} +/- {round(result[5],4)}")
  print(f"efficiency D (C/N system) = {round(result[12],4)} +/- {round(result[13],4)}")
  ```

      efficiency S = 0.9622 +/- 0.0045
      efficiency D = 0.9163 +/- 0.007
      efficiency T = 0.8482 +/- 0.0096
      efficiency D (C/N system) = 0.9037 +/- 0.0074





  ```python
  TD = 0.977667386529166     # TDCR parameter
  ```


  ```python
  result = tdcrpy.TDCRPy.eff(TD, Rad, pmf_1, kB, V)
  ```

      global free parameter = 4.999573818598962 keV-1



  ```python
  print(f"free parameter = {round(result[0],4)} keV-1")
  print(f"efficiency S = {round(result[2],4)} +/- {round(result[3],4)}")
  print(f"efficiency D = {round(result[4],4)} +/- {round(result[5],4)}")
  print(f"efficiency T = {round(result[6],4)} +/- {round(result[7],4)}")
  print(f"efficiency D (C/N system) = {round(result[14],4)} +/- {round(result[15],4)}")
  ```

      free parameter = 4.9996 keV-1
      efficiency S = 0.9835 +/- 0.001
      efficiency D = 0.9677 +/- 0.0015
      efficiency T = 0.9397 +/- 0.002
      efficiency D (C/N system) = 0.9629 +/- 0.0016



  ```python

  ```



  ```python
  import tdcrpy as td
  ```




  ```python
  print("\nparameters in a list: ", td.TDCR_model_lib.readParameters(disp=True))
  ```

      number of integration bins for electrons = 1000
      number of integration bins for alpha = 1000
      density = 0.96 g/cm3
      Z = 5.2
      A = 11.04
      depth of spline interp. = 5
      energy above which interp. in implemented (for alpha) = 100.0 keV
      energy above which interp. in implemented (for electron) = 1.5 keV
      activation of the micelle correction = False
      diameter of micelle = 2.0 nm
      acqueous fraction = 0.1
      coincidence resolving time = 50 ns
      extended dead time = 10 µs
      measurement time = 20 min

      parameters in a list:  (1000, 1000, 0.96, 5.2, 11.04, 5, 100.0, 1.5, 2.0, 0.1, 50, 10, 20, False)





  ```python
  td.TDCR_model_lib.modifynE_electron(100)
  print("New configuration:")
  td.TDCR_model_lib.readParameters(disp=True)

  td.TDCR_model_lib.modifynE_electron(1000)
  ```

      New configuration:
      number of integration bins for electrons = 100
      number of integration bins for alpha = 1000
      density = 0.96 g/cm3
      Z = 5.2
      A = 11.04
      depth of spline interp. = 5
      energy above which interp. in implemented (for alpha) = 100.0 keV
      energy above which interp. in implemented (for electron) = 1.5 keV
      activation of the micelle correction = False
      diameter of micelle = 2.0 nm
      acqueous fraction = 0.1
      coincidence resolving time = 50 ns
      extended dead time = 10 µs
      measurement time = 20 min





  ```python
  td.TDCR_model_lib.modifynE_alpha(100)
  print("New configuration:")
  td.TDCR_model_lib.readParameters(disp=True)

  td.TDCR_model_lib.modifynE_alpha(1000)
  ```

      New configuration:
      number of integration bins for electrons = 1000
      number of integration bins for alpha = 100
      density = 0.96 g/cm3
      Z = 5.2
      A = 11.04
      depth of spline interp. = 5
      energy above which interp. in implemented (for alpha) = 100.0 keV
      energy above which interp. in implemented (for electron) = 1.5 keV
      activation of the micelle correction = False
      diameter of micelle = 2.0 nm
      acqueous fraction = 0.1
      coincidence resolving time = 50 ns
      extended dead time = 10 µs
      measurement time = 20 min





  ```python
  td.TDCR_model_lib.modifyDensity(1.02)
  print("New configuration:")
  td.TDCR_model_lib.readParameters(disp=True)

  td.TDCR_model_lib.modifyDensity(0.96)
  ```

      New configuration:
      number of integration bins for electrons = 1000
      number of integration bins for alpha = 1000
      density = 1.02 g/cm3
      Z = 5.2
      A = 11.04
      depth of spline interp. = 5
      energy above which interp. in implemented (for alpha) = 100.0 keV
      energy above which interp. in implemented (for electron) = 1.5 keV
      activation of the micelle correction = False
      diameter of micelle = 2.0 nm
      acqueous fraction = 0.1
      coincidence resolving time = 50 ns
      extended dead time = 10 µs
      measurement time = 20 min





  ```python
  td.TDCR_model_lib.modifyZ(5.7)
  print("New configuration:")
  td.TDCR_model_lib.readParameters(disp=True)

  td.TDCR_model_lib.modifyZ(5.2)
  ```

      New configuration:
      number of integration bins for electrons = 1000
      number of integration bins for alpha = 1000
      density = 0.96 g/cm3
      Z = 5.7
      A = 11.04
      depth of spline interp. = 5
      energy above which interp. in implemented (for alpha) = 100.0 keV
      energy above which interp. in implemented (for electron) = 1.5 keV
      activation of the micelle correction = False
      diameter of micelle = 2.0 nm
      acqueous fraction = 0.1
      coincidence resolving time = 50 ns
      extended dead time = 10 µs
      measurement time = 20 min





  ```python
  td.TDCR_model_lib.modifyA(12.04)
  print("New configuration:")
  td.TDCR_model_lib.readParameters(disp=True)

  td.TDCR_model_lib.modifyA(11.04)
  ```

      New configuration:
      number of integration bins for electrons = 1000
      number of integration bins for alpha = 1000
      density = 0.96 g/cm3
      Z = 5.2
      A = 12.04
      depth of spline interp. = 5
      energy above which interp. in implemented (for alpha) = 100.0 keV
      energy above which interp. in implemented (for electron) = 1.5 keV
      activation of the micelle correction = False
      diameter of micelle = 2.0 nm
      acqueous fraction = 0.1
      coincidence resolving time = 50 ns
      extended dead time = 10 µs
      measurement time = 20 min





  ```python
  td.TDCR_model_lib.modifyDepthSpline(7)
  print("New configuration:")
  td.TDCR_model_lib.readParameters(disp=True)

  td.TDCR_model_lib.modifyDepthSpline(5)
  ```

      New configuration:
      number of integration bins for electrons = 1000
      number of integration bins for alpha = 1000
      density = 0.96 g/cm3
      Z = 5.2
      A = 11.04
      depth of spline interp. = 7
      energy above which interp. in implemented (for alpha) = 100.0 keV
      energy above which interp. in implemented (for electron) = 1.5 keV
      activation of the micelle correction = False
      diameter of micelle = 2.0 nm
      acqueous fraction = 0.1
      coincidence resolving time = 50 ns
      extended dead time = 10 µs
      measurement time = 20 min





  ```python
  td.TDCR_model_lib.modifyEinterp_a(200)
  print("New configuration:")
  td.TDCR_model_lib.readParameters(disp=True)

  td.TDCR_model_lib.modifyEinterp_a(100)
  ```

      New configuration:
      number of integration bins for electrons = 1000
      number of integration bins for alpha = 1000
      density = 0.96 g/cm3
      Z = 5.2
      A = 11.04
      depth of spline interp. = 5
      energy above which interp. in implemented (for alpha) = 200.0 keV
      energy above which interp. in implemented (for electron) = 1.5 keV
      activation of the micelle correction = False
      diameter of micelle = 2.0 nm
      acqueous fraction = 0.1
      coincidence resolving time = 50 ns
      extended dead time = 10 µs
      measurement time = 20 min





  ```python
  td.TDCR_model_lib.modifyEinterp_e(2.0)
  print("New configuration:")
  td.TDCR_model_lib.readParameters(disp=True)

  td.TDCR_model_lib.modifyEinterp_e(1.5)
  ```

      New configuration:
      number of integration bins for electrons = 1000
      number of integration bins for alpha = 1000
      density = 0.96 g/cm3
      Z = 5.2
      A = 11.04
      depth of spline interp. = 5
      energy above which interp. in implemented (for alpha) = 100.0 keV
      energy above which interp. in implemented (for electron) = 2.0 keV
      activation of the micelle correction = False
      diameter of micelle = 2.0 nm
      acqueous fraction = 0.1
      coincidence resolving time = 50 ns
      extended dead time = 10 µs
      measurement time = 20 min





  ```python
  td.TDCR_model_lib.modifyMicCorr(False)
  print("New configuration:")
  td.TDCR_model_lib.readParameters(disp=True)

  td.TDCR_model_lib.modifyMicCorr(True)
  ```

      New configuration:
      number of integration bins for electrons = 1000
      number of integration bins for alpha = 1000
      density = 0.96 g/cm3
      Z = 5.2
      A = 11.04
      depth of spline interp. = 5
      energy above which interp. in implemented (for alpha) = 100.0 keV
      energy above which interp. in implemented (for electron) = 1.5 keV
      activation of the micelle correction = False
      diameter of micelle = 2.0 nm
      acqueous fraction = 0.1
      coincidence resolving time = 50 ns
      extended dead time = 10 µs
      measurement time = 20 min





  ```python
  td.TDCR_model_lib.modifyDiam_micelle(4.0)
  print("New configuration:")
  td.TDCR_model_lib.readParameters(disp=True)

  td.TDCR_model_lib.modifyDiam_micelle(2.0)
  ```

      New configuration:
      number of integration bins for electrons = 1000
      number of integration bins for alpha = 1000
      density = 0.96 g/cm3
      Z = 5.2
      A = 11.04
      depth of spline interp. = 5
      energy above which interp. in implemented (for alpha) = 100.0 keV
      energy above which interp. in implemented (for electron) = 1.5 keV
      activation of the micelle correction = False
      diameter of micelle = 4.0 nm
      acqueous fraction = 0.1
      coincidence resolving time = 50 ns
      extended dead time = 10 µs
      measurement time = 20 min





  ```python
  td.TDCR_model_lib.modifyfAq(0.2)
  print("New configuration:")
  td.TDCR_model_lib.readParameters(disp=True)

  td.TDCR_model_lib.modifyfAq(0.1)
  ```

      New configuration:
      number of integration bins for electrons = 1000
      number of integration bins for alpha = 1000
      density = 0.96 g/cm3
      Z = 5.2
      A = 11.04
      depth of spline interp. = 5
      energy above which interp. in implemented (for alpha) = 100.0 keV
      energy above which interp. in implemented (for electron) = 1.5 keV
      activation of the micelle correction = False
      diameter of micelle = 2.0 nm
      acqueous fraction = 0.2
      coincidence resolving time = 50 ns
      extended dead time = 10 µs
      measurement time = 20 min





  ```python
  td.TDCR_model_lib.modifyTau(100)
  print("New configuration:")
  td.TDCR_model_lib.readParameters(disp=True)

  td.TDCR_model_lib.modifyTau(50)
  ```

      New configuration:
      number of integration bins for electrons = 1000
      number of integration bins for alpha = 1000
      density = 0.96 g/cm3
      Z = 5.2
      A = 11.04
      depth of spline interp. = 5
      energy above which interp. in implemented (for alpha) = 100.0 keV
      energy above which interp. in implemented (for electron) = 1.5 keV
      activation of the micelle correction = False
      diameter of micelle = 2.0 nm
      acqueous fraction = 0.1
      coincidence resolving time = 100 ns
      extended dead time = 10 µs
      measurement time = 20 min





  ```python
  td.TDCR_model_lib.modifyDeadTime(100)
  print("New configuration:")
  td.TDCR_model_lib.readParameters(disp=True)

  td.TDCR_model_lib.modifyDeadTime(10)
  ```

      New configuration:
      number of integration bins for electrons = 1000
      number of integration bins for alpha = 1000
      density = 0.96 g/cm3
      Z = 5.2
      A = 11.04
      depth of spline interp. = 5
      energy above which interp. in implemented (for alpha) = 100.0 keV
      energy above which interp. in implemented (for electron) = 1.5 keV
      activation of the micelle correction = False
      diameter of micelle = 2.0 nm
      acqueous fraction = 0.1
      coincidence resolving time = 50 ns
      extended dead time = 100 µs
      measurement time = 20 min





  ```python
  td.TDCR_model_lib.modifyMeasTime(60)
  print("New configuration:")
  td.TDCR_model_lib.readParameters(disp=True)

  td.TDCR_model_lib.modifyMeasTime(20)
  ```

      New configuration:
      number of integration bins for electrons = 1000
      number of integration bins for alpha = 1000
      density = 0.96 g/cm3
      Z = 5.2
      A = 11.04
      depth of spline interp. = 5
      energy above which interp. in implemented (for alpha) = 100.0 keV
      energy above which interp. in implemented (for electron) = 1.5 keV
      activation of the micelle correction = False
      diameter of micelle = 2.0 nm
      acqueous fraction = 0.1
      coincidence resolving time = 50 ns
      extended dead time = 10 µs
      measurement time = 60 min



  ```python
  import tdcrpy as td
  import matplotlib.pyplot as plt
  import numpy as np
  ```


  ```python
  radionuclide = "Sr-89"
  mode = "beta-" # 'beta-' or 'beta+'
  level = 'tot'  # 0,1,2,3 .... or 'tot'
  ```




  ```python
  print(td.TDCR_model_lib.readBetaShapeInfo(radionuclide,mode,level))
  ```

      -Beta Spectrum of the main transition from BetaShape 2.4
       (05/2024), DDEP 2004 evaluation and Q-value from AME2020-





  ```python
  energy, probability = td.TDCR_model_lib.readBetaShape(radionuclide,mode,level)

  plt.figure("Energy spectrum")
  plt.clf()
  plt.plot(energy[:-1], probability)
  plt.xlabel(r'$E$ /keV', fontsize=14)
  plt.ylabel(r'$p(E)$ /(keV$^{-1}$)', fontsize=14)
  ```




      Text(0, 0.5, '$p(E)$ /(keV$^{-1}$)')





  ![png](docs/readBetaSpectrum/output_7_1.png)





  This spectrum is built by TDCRPy (function `buildBetaSpectra`) to be used for the analytical TDCR model


  ```python
  energy2, probability2 = td.TDCR_model_lib.readBetaSpectra(radionuclide)

  plt.figure("Deposied energy spectrum")
  plt.clf()
  plt.plot(energy[:-1], probability,'-b', label="emitted energy spectrum")
  plt.plot(energy2, probability2,'-r', label="deposited energy spectrum")
  plt.legend(fontsize=14)
  plt.xlabel(r'$E$ /keV', fontsize=14)
  plt.ylabel(r'$p(E)$ /(keV$^{-1}$)', fontsize=14)
  ```




      Text(0, 0.5, '$p(E)$ /(keV$^{-1}$)')





  ![png](docs/readBetaSpectrum/output_9_1.png)




  ```python

  ```



  ```python
  import tdcrpy as td
  import matplotlib.pyplot as plt
  import numpy as np
  ```




  ```python
  density = 0.96 # in g/cm3
  energy = 100 # keV
  result_alpha = td.TDCR_model_lib.stoppingpowerA(energy,rho=density)
  result_electron = td.TDCR_model_lib.stoppingpower(energy*1e3,rho=density)
  print(f"dE/dx = {result_alpha:.7g} keV/cm for alpha particles" )
  print(f"dE/dx = {result_electron*1e3:.4g} keV/cm for electrons" )
  ```

      dE/dx = 1461120 keV/cm for alpha particles
      dE/dx = 3419 keV/cm for electrons





  ```python
  energy_vec = np.logspace(-2,4,1000) # in keV
  w_a, w_e = [], []
  for e in energy_vec:
          w_a.append(td.TDCR_model_lib.stoppingpowerA(e,rho=density))
          w_e.append(1e3*td.TDCR_model_lib.stoppingpower(e*1e3,rho=density))
  plt.figure("Stopping power")
  plt.clf()
  plt.plot(energy_vec,w_a,"-k",label="alpha particles")
  plt.plot(energy_vec,w_e,"-r",label="electrons")
  plt.xscale('log')
  plt.xlabel(r'$E$ /keV', fontsize=14)
  plt.ylabel(r'd$E$/d$x$ /(keV/cm)', fontsize=14)
  plt.legend()
  ```




      <matplotlib.legend.Legend at 0x25d905a4c90>





  ![png](docs/stoppingPower/output_6_1.png)



  ```python
  import tdcrpy as td
  import matplotlib.pyplot as plt
  import numpy as np
  ```




  ```python
  kB = 0.01 # Birks constant in cm/MeV
  ei = 1000  # initial energy in keV
  ed = 1000  # deposited energy in keV
  nE = 10000  # number of points of the energy linear space
  eq_e=td.TDCR_model_lib.E_quench_e(ei*1e3,ed*1e3,kB,nE)*1e-3
  print(f"For electrons       => Initial energy = {ei} keV, deposited energy = {ed} keV, quenched energy = {eq_e:.5g} keV")
  eq_a=td.TDCR_model_lib.E_quench_a(ei,kB*1e-3,nE)
  print(f"For alpha particles => Initial energy = {ei} keV, quenched energy = {eq_a:.5g} keV")
  ```

      For electrons       => Initial energy = 1000 keV, deposited energy = 1000 keV, quenched energy = 975.24 keV
      For alpha particles => Initial energy = 1000 keV, quenched energy = 48.934 keV




  The deposited energy ratios were evaluation by GEANT4-DNA [1].

  [1] Nedjadi, Y., Laedermann, J.-P., Bochud, F., Bailat, C., 2017. On the reverse micelle effect in liquid scintillation counting. Applied Radiation and Isotopes 125, 94–107. https://doi.org/10.1016/j.apradiso.2017.04.020


  ```python
  energy_vec = np.logspace(-2,4,100) # in keV
  fAq=0.1
  s05, s1, s2, s3, s4, s5, s6, s7, s8, s10 = [], [], [], [], [], [], [], [], [], []
  for e in energy_vec:
      s05.append(td.TDCR_model_lib.micelleLoss(e,fAq=fAq,diam_micelle=0.5))
      s1.append(td.TDCR_model_lib.micelleLoss(e,fAq=fAq,diam_micelle=1.0))
      s2.append(td.TDCR_model_lib.micelleLoss(e,fAq=fAq,diam_micelle=2.0))
      s3.append(td.TDCR_model_lib.micelleLoss(e,fAq=fAq,diam_micelle=3.0))
      s4.append(td.TDCR_model_lib.micelleLoss(e,fAq=fAq,diam_micelle=4.0))
      s5.append(td.TDCR_model_lib.micelleLoss(e,fAq=fAq,diam_micelle=5.0))
      s6.append(td.TDCR_model_lib.micelleLoss(e,fAq=fAq,diam_micelle=6.0))
      s7.append(td.TDCR_model_lib.micelleLoss(e,fAq=fAq,diam_micelle=7.0))
      s8.append(td.TDCR_model_lib.micelleLoss(e,fAq=fAq,diam_micelle=8.0))
      s10.append(td.TDCR_model_lib.micelleLoss(e,fAq=fAq,diam_micelle=10.0))

  plt.figure("Deposited energy ratio")
  plt.clf()
  plt.plot(energy_vec,s05,label="$\Phi$=0.5 nm")
  plt.plot(energy_vec,s1,label="$\Phi$=1.0 nm")
  plt.plot(energy_vec,s2,label="$\Phi$=2.0 nm")
  plt.plot(energy_vec,s3,label="$\Phi$=3.0 nm")
  plt.plot(energy_vec,s4,label="$\Phi$=4.0 nm")
  plt.plot(energy_vec,s5,label="$\Phi$=5.0 nm")
  plt.plot(energy_vec,s6,label="$\Phi$=6.0 nm")
  plt.plot(energy_vec,s7,label="$\Phi$=7.0 nm")
  plt.plot(energy_vec,s8,label="$\Phi$=8.0 nm")
  plt.plot(energy_vec,s10,label="$\Phi$=10.0 nm")
  plt.xscale('log')
  plt.xlabel(r'$E$ /keV', fontsize=14)
  plt.ylabel(r'$S(E)/E$', fontsize=14)
  plt.legend()
  ```




      <matplotlib.legend.Legend at 0x2dab792de10>





  ![png](docs/quenchingModel/output_6_1.png)






  ```python
  energy_vec = np.logspace(-2,4,100) # in keV
  fAq = 0.1 # acqueous fraction
  diam_micelle = 4.0 # diameter of micelles (in nm)

  eq_a, eq_e, eq_e_m = [], [], []
  for e in energy_vec:
          eq_e.append(td.TDCR_model_lib.E_quench_e(e*1e3,e*1e3,kB,nE)*1e-3)
          eq_e_m.append(td.TDCR_model_lib.E_quench_e(e*1e3,e*1e3,kB,nE)*1e-3*td.TDCR_model_lib.micelleLoss(e,fAq=fAq,diam_micelle=diam_micelle))
          eq_a.append(td.TDCR_model_lib.E_quench_a(e,kB*1e-3,nE))

  plt.figure("Quenched Energy")
  plt.clf()
  plt.plot(energy_vec,eq_a/energy_vec,"-k",label="alpha particles")
  plt.plot(energy_vec,eq_e/energy_vec,"-r",label="electrons")
  plt.plot(energy_vec,eq_e_m/energy_vec,"--r",label="electrons (micelle effect)")
  plt.xscale('log')
  plt.xlabel(r'$E$ /keV', fontsize=14)
  plt.ylabel(r'$Q_t(E)/E$', fontsize=14)
  plt.legend()
  ```




      <matplotlib.legend.Legend at 0x2dab779f910>





  ![png](docs/quenchingModel/output_8_1.png)




  ```python

  ```

  ```python

  ```

  ```python

  ```


  ```python
  import tdcrpy as td
  import matplotlib.pyplot as plt
  import numpy as np
  import cv2
  ```




  ```python
  A = td.TDCR_model_lib.Matrice10_e_1
  C = np.flipud(A[0:])
  C = np.clip(C, a_min=7e-6, a_max=1e-1)
  C = np.log(C)
  C = cv2.GaussianBlur(C, (3, 5), 10)
  extent = [A[0,0], A[0,-1], 0, A[0,-1]]
  x = np.arange(0, A[0,-1], A[0,-1]/10)
  y = np.arange(0, A[0,-1], A[0,-1]/10)

  plt.imshow(C, extent=extent, cmap='Greys', interpolation='nearest')
  plt.colorbar()
  plt.xticks(x)
  plt.yticks(y)
  plt.xlabel(r"$E_0$ /keV", fontsize=14)
  plt.ylabel(r"$E_1$ /keV", fontsize=14)
  plt.savefig("electrons_0-200.png")
  plt.show()
  ```



  ![png](docs/interaction/output_7_0.png)






  ```python
  A = td.TDCR_model_lib.Matrice10_e_2
  C = np.flipud(A[0:])
  C = np.clip(C, a_min=1e-5, a_max=1e-0)
  C = np.log(C)
  C = cv2.GaussianBlur(C, (3, 3), 20)
  extent = [A[0,0], A[0,-1], 0, A[0,-1]]
  x = np.arange(A[0,0], A[0,-1], A[0,-1]/10)
  y = np.arange(0, A[0,-1], A[0,-1]/10)

  plt.imshow(C, extent=extent, cmap='Greys', interpolation='nearest')
  plt.colorbar()
  plt.xticks(x, rotation=20)
  plt.yticks(y)
  plt.xlabel(r"$E_0$ /keV", fontsize=14)
  plt.ylabel(r"$E_1$ /keV", fontsize=14)
  plt.tight_layout()
  plt.savefig("electrons_200-2000.png")
  plt.show()
  ```



  ![png](docs/interaction/output_9_0.png)






  ```python
  A = td.TDCR_model_lib.Matrice10_e_3
  C = np.flipud(A[0:])
  C = np.clip(C, a_min=1e-5, a_max=1e-0)
  C = np.log(C)
  C = cv2.GaussianBlur(C, (3, 3), 20)
  extent = [A[0,0], A[0,-1], 0, A[0,-1]]
  x = np.arange(A[0,0], A[0,-1], A[0,-1]/10)
  y = np.arange(0, A[0,-1], A[0,-1]/10)

  plt.imshow(C, extent=extent, cmap='Greys', interpolation='nearest')
  plt.colorbar()
  plt.xticks(x, rotation=20)
  plt.yticks(y)
  plt.xlabel(r"$E_0$ /keV", fontsize=14)
  plt.ylabel(r"$E_1$ /keV", fontsize=14)
  plt.tight_layout()
  plt.savefig("electrons_2000-10000.png")
  plt.show()
  ```



  ![png](docs/interaction/output_11_0.png)






  ```python
  A = td.TDCR_model_lib.Matrice10_p_1
  C = np.flipud(A[0:])
  C = np.clip(C, a_min=1e-7, a_max=1e0)
  C = np.log(C)
  C = cv2.GaussianBlur(C, (3, 3), 20)
  extent = [A[0,0], A[0,-1], 0, A[0,-1]]
  x = np.arange(0, A[0,-1], A[0,-1]/10)
  y = np.arange(0, A[0,-1], A[0,-1]/10)

  plt.imshow(C, extent=extent, cmap='Greys', interpolation='nearest')
  plt.colorbar()
  plt.xticks(x)
  plt.yticks(y)
  plt.xlabel(r"$E_0$ /keV", fontsize=14)
  plt.ylabel(r"$E_1$ /keV", fontsize=14)
  plt.savefig("photons_0-200.png")
  plt.show()

  x_1 = 1


  col_idx = np.searchsorted(A[0, :], x_1)


  y_1 = C[:, col_idx]
  x_plot = 0.2*np.arange(0, len(y_1), 1)

  print("escape probability = ",np.exp(y_1[-2])/sum(np.exp(y_1)))

  plt.plot(x_plot,np.flipud(y_1))
  plt.xlabel(r"$E_1$ /keV", fontsize=14)
  plt.ylabel(r"log($P(E_1|E_0)$)", fontsize=14)
  plt.title(f"Distribution for $x_1 = {x_1}$ keV")
  plt.grid(True)
  plt.xlim([0,x_1*1.5])
  plt.savefig(f"distribution_x_{x_1}.png")
  plt.show()
  ```



  ![png](docs/interaction/output_13_0.png)

      escape probability =  0.5623307322837948

  ![png](docs/interaction/output_13_2.png)






  ```python
  A = td.TDCR_model_lib.Matrice10_p_2
  C = np.flipud(A[0:])
  C = np.clip(C, a_min=1e-7, a_max=1e0)
  C = np.log(C)
  C = cv2.GaussianBlur(C, (3, 3), 20)
  extent = [A[0,0], A[0,-1], 0, A[0,-1]]
  x = np.arange(A[0,0], A[0,-1], A[0,-1]/10)
  y = np.arange(0, A[0,-1], A[0,-1]/10)

  plt.imshow(C, extent=extent, cmap='Greys', interpolation='nearest')
  plt.colorbar()
  plt.xticks(x, rotation=20)
  plt.yticks(y)
  plt.xlabel(r"$E_0$ /keV", fontsize=14)
  plt.ylabel(r"$E_1$ /keV", fontsize=14)
  plt.tight_layout()
  plt.savefig("photons_200-2000.png")
  plt.show()

  x_1 = 2000


  col_idx = np.searchsorted(A[0, :], x_1)


  y_1 = np.log(A[:, col_idx])
  x_plot = 2*np.arange(0, len(y_1), 1)

  print("escape probability = ",np.exp(y_1[0]))

  plt.plot(x_plot,y_1)
  plt.xlabel(r"$E_1$ /keV", fontsize=14)
  plt.ylabel(r"log($P(E_1|E_0)$)", fontsize=14)
  plt.title(f"Distribution for $x_1 = {x_1}$ keV")
  plt.grid(True)
  plt.xlim([0,x_1*1.5])
  plt.savefig(f"distribution_x_{x_1}.png")
  plt.show()
  ```



  ![png](docs/interaction/output_15_0.png)

      escape probability =  1999.9999999999998

  ![png](docs/interaction/output_15_3.png)






  ```python
  A = td.TDCR_model_lib.Matrice10_p_3
  C = np.flipud(A[1:])
  C = np.clip(C, a_min=1e-6, a_max=1e-2)
  C = np.log(C)
  C = cv2.GaussianBlur(C, (5, 5), 20)
  extent = [A[0,0], A[0,-1], 0, A[0,-1]]
  x = np.arange(A[0,0], A[0,-1], A[0,-1]/10)
  y = np.arange(0, A[0,-1], A[0,-1]/10)

  plt.imshow(C, extent=extent, cmap='Greys', interpolation='nearest')
  plt.colorbar()
  plt.xticks(x, rotation=20)
  plt.yticks(y)
  plt.xlabel(r"$E_0$ /keV", fontsize=14)
  plt.ylabel(r"$E_1$ /keV", fontsize=14)
  plt.tight_layout()
  plt.savefig("photons_2000-10000.png")
  plt.show()

  x_1 = 5000


  col_idx = np.searchsorted(A[0, :], x_1)


  y_1 = C[:, col_idx]
  x_plot = 10*np.arange(0, len(y_1), 1)

  print("escape probability = ",np.exp(y_1[-1])/sum(np.exp(y_1)))

  plt.plot(x_plot,np.flipud(y_1))
  plt.xlabel(r"$E_1$ /keV", fontsize=14)
  plt.ylabel(r"log($P(E_1|E_0)$)", fontsize=14)
  plt.title(f"Distribution for $x_1 = {x_1}$ keV")
  plt.grid(True)
  plt.xlim([0,x_1*1.5])
  plt.savefig(f"distribution_x_{x_1}.png")
  plt.show()
  ```



  ![png](docs/interaction/output_17_0.png)

      escape probability =  0.03360101175407434

  ![png](output_17_2.png)






  ```python
  ei = 100  # initial energy in keV
  v = 10     # volume of the scintillator in mL
  ed_g=td.TDCR_model_lib.energie_dep_gamma2(ei,v)
  ed_e=td.TDCR_model_lib.energie_dep_beta2(ei,v)
  print(f"The gamma ray of initial energy = {ei} keV, has deposited = {ed_g} keV in the scintillant.")
  print(f"The electron of initial energy = {ei} keV, has deposited = {ed_e} keV in the scintillant.")
  ```

      The gamma ray of initial energy = 100 keV, has deposited = 0 keV in the scintillant.
      The electron of initial energy = 100 keV, has deposited = 100 keV in the scintillant.





  ```python
  V=np.arange(8,21,0.1)
  N=100000
  E=15    # initial energy in keV
  e_vec, ue_vec = [], []
  for v in V:
      x=[]
      for i in range(N):
          out=td.TDCR_model_lib.energie_dep_gamma2(15,v)
          x.append(out)
      e_vec.append(np.mean(x))
      ue_vec.append(np.std(x)/np.sqrt(N))

  ```


  ```python
  plt.figure(r"Ed vs volume")
  plt.clf()
  plt.errorbar(V, e_vec, yerr=ue_vec, fmt="-k", label=rf'$E_0$ = {E} keV')
  plt.legend()
  plt.xlabel(r"$V$ /mL", fontsize=14)
  plt.ylabel(r"$\bar{y}$ /(keV)", fontsize=14)
  ```


  ![png](docs/interaction/output_22_1.png)


  ```python

  ```



  ```python
  import tdcrpy as td
  import numpy as np
  from tqdm import tqdm
  import matplotlib.pyplot as plt
  ```


  ```python
  mode = "eff"                # ask for efficiency calculation
  Rad="Co-60"                 # radionuclides
  pmf_1="1"                   # relatives fractions of the radionulides
  N = 1000                     # number of Monte Carlo trials
  kB =1.0e-5                  # Birks constant in cm keV-1
  V = 10                      # volume of scintillator in mL
  L=np.logspace(-3,2,num=100) # free parameter in keV-1


  td.TDCRPy.TDCRPy(L[0], Rad, pmf_1, N, kB, V, mode, barp=True, record=True)

  effS, u_effS, effD, u_effD, effT, u_effT, effD2, u_effD2 = [], [],[], [],[], [], [], []
  for l in tqdm(L, desc="free parameters ", unit=" iterations"):
    out = td.TDCRPy.TDCRPy(l, Rad, pmf_1, N, kB, V, mode, readRecHist=True)
    effS.append(out[2])
    u_effS.append(out[3])
    effD.append(out[2])
    u_effD.append(out[3])
    effT.append(out[4])
    u_effT.append(out[5])
    effD2.append(out[12])
    u_effD2.append(out[13])
  ```


       ______  ______  ______ _______  ________
      |__  __||  ___ \|  ___||  ___ | |  ____ |
        | |   | |  | || |    | |  | | | |___| |___     ___
        | |   | |  | || |    | |__| | |  _____|\  \   |  |
        | |   | |__| || |____|  __  \ | |       \  \  |  |
        |_|   |_____/ |_____||_|  \__\|_|        \  \_|  |
        +++++++++++++++++++++++++++++++++++++++++/      /
        ________________________________________/      /
       |______________________________________________/


      version 2.0.2
      BIPM 2023 - license MIT
      distribution: https://pypi.org/project/TDCRPy
      developement: https://github.com/RomainCoulon/TDCRPy

      start calculation...


      Processing: 100%|█████████████████████████████████████████████████████████████| 1000/1000 [00:24<00:00, 40.79 decays/s]
      free parameters : 100%|█████████████████████████████████████████████████████| 100/100 [00:02<00:00, 35.96 iterations/s]



  ```python
  effS=np.asarray(effS)
  effT=np.asarray(effT)
  effD=np.asarray(effD)
  effD2=np.asarray(effD2)
  u_effS=np.asarray(u_effS)
  u_effT=np.asarray(u_effT)
  u_effD=np.asarray(u_effD)
  u_effD2=np.asarray(u_effD2)

  tdcr=effT/effD
  u_tdcr=np.sqrt(u_effD**2*effT**2/effD**4+u_effT**2/effD**2)

  plt.figure("efficiency vs free parameter")
  plt.clf()
  plt.errorbar(L,effD,yerr=u_effD,fmt="-k",label="double coincidences")
  plt.errorbar(L,effT,yerr=u_effT,fmt="-r",label="triple coincidences")
  plt.errorbar(L,effD2,yerr=u_effD2,fmt="-g",label="double coincidences (CIEMAT/NIST)")
  plt.xscale('log')
  plt.xlabel(r'$L$ /keV$^{-1}$', fontsize=14)
  plt.ylabel(r'$\epsilon$', fontsize=14)
  plt.legend()

  plt.figure("efficiency vs TDCR")
  plt.clf()
  plt.errorbar(tdcr,effD,xerr=u_tdcr,yerr=u_effD,fmt="-k")

  plt.xlabel(r'$R_T/R_D$', fontsize=14)
  plt.ylabel(r'$\epsilon_{D}$', fontsize=14)
  ```


  ![png](docs/efficiencyCurve/output_4_1.png)


  ![png](docs/efficiencyCurve/output_4_2.png)




  ```python
  import tdcrpy as td
  import matplotlib.pyplot as plt
  import numpy as np
  from tqdm import tqdm
  ```



  ```python
  mode = "eff"                # ask for efficiency calculation
  Rad = "Fe-55, Ni-63"        # list of radionuclides
  pmf_1="1"                   # relatives fractions of the radionulides
  N = 1000                    # number of Monte Carlo trials
  kB =1.0e-5                  # Birks constant in cm keV-1
  V = 10                      # volume of scintillator in mL
  L=1                         # free parameter in keV-1
  ```



  ```python
  C = np.arange(0,1,0.05)     # relative fraction of the second nuclide
  ```



  ```python
  effS, ueffS, effD, ueffD, effT, ueffT, effD2, ueffD2 = [], [], [], [], [], [], [], []
  for i in tqdm(C, desc="Processing items"):
      pmf_1 = f"{1-i}, {i}"
      result = td.TDCRPy.TDCRPy(L, Rad, pmf_1, N, kB, V, mode)
      effS.append(result[0]); ueffS.append(result[1])
      effD.append(result[2]); ueffD.append(result[3])
      effT.append(result[4]); ueffT.append(result[5])
      effD2.append(result[12]); ueffD2.append(result[13])
  effD = np.asarray(effD); ueffD = np.asarray(ueffD)
  effD2 = np.asarray(effD2); ueffD2 = np.asarray(ueffD2)
  effT = np.asarray(effT); ueffT = np.asarray(ueffT)
  TDCR = effT/effD
  ```

      Processing items: 100%|████████████████████████████████████████████████████████████████| 20/20 [03:52<00:00, 11.63s/it]





  ```python
  plt.figure("Stopping power")
  plt.clf()
  plt.errorbar(C,effD,yerr=2*ueffD,fmt="-k",label=r"$\epsilon_D$")
  plt.errorbar(C,TDCR,yerr=2*ueffD,fmt="-r",label=r"$\epsilon_T/\epsilon_D$")
  plt.errorbar(C,effD2,yerr=2*ueffD2,fmt="-g",label=r"$\epsilon_{D2}$ (CIEMAT/NIST)")

  plt.xlabel(f'relative fraction of {Rad.split(",")[1]}', fontsize=14)
  plt.ylabel(r' ', fontsize=14)
  plt.legend()
  plt.savefig("stopping_power_plot.png")
  ```

  ![png](docs/mixture/output_10_0.png)



  This notebook presents how to link the `TDCRPy` package with the `radioactivedecay` package [1] to simulate dynamic TDCR measurements.

  [1] Alex Malins & Thom Lemoine, radioactivedecay: A Python package for radioactive decay calculations. Journal of Open Source Software, 7 (71), 3318 (2022). https://doi.org/10.21105/joss.03318.


  ```python

  ```


  ```python
  import radioactivedecay as rd
  import tdcrpy as td
  import numpy as np
  import matplotlib.pyplot as plt
  ```




  ```python
  radionuclide = 'Mo-99' # parent nuclide decaying during the measurement
  activity_unit = "Bq"   # unit of the initial activity
  time_unit = "h"        # time unit of the decay process
  A0 = 1                 # initial activity (set to 1 in order to obtain relative activities)
  coolingTime = 30.0     # the cooling time

  mode = "eff"
  L = 1                  # free parameter (keV-1)
  kB = 1e-5              # Birks constant cm/keV
  V = 10                 # volume of scintillator (mL)
  N = 1000                # number of simulated decays
  ```




  ```python
  rad_t0 = rd.Inventory({radionuclide: A0}, activity_unit)
  rad_t1 = rad_t0.decay(coolingTime, time_unit)
  A_t1 = rad_t1.activities(activity_unit)
  As_t1 = sum(A_t1.values())
  print(f"Activity at {coolingTime} {time_unit}")
  for key, val in A_t1.items(): print(f"\t {key}: {val} {activity_unit}")
  print("Total activity = ", As_t1, activity_unit)
  print(f"Relative activity at {coolingTime} {time_unit}")
  for key, val in A_t1.items(): print(f"\t {key}: {val/As_t1}")
  ```

      Activity at 30.0 h
      	 Mo-99: 0.7295308772422591 Bq
      	 Ru-99: 0.0 Bq
      	 Tc-99: 7.44742326547114e-09 Bq
      	 Tc-99m: 0.6738301487178286 Bq
      Total activity =  1.4033610334075108 Bq
      Relative activity at 30.0 h
      	 Mo-99: 0.5198454708913215
      	 Ru-99: 0.0
      	 Tc-99: 5.306847695056773e-09
      	 Tc-99m: 0.4801545238018309





  ```python
  nuc = rd.Nuclide(radionuclide)
  nuc.plot()
  ```

  ![png](docs/dynamicDecay/output_9_1.png)




  ```python
  rad_t0 .plot(coolingTime, time_unit, yunits=activity_unit)
  ```

  ![png](output_11_1.png)






  ```python
  timeVec = np.arange(0,30,2) # time vector
  effS, ueffS, effD, ueffD, effT, ueffT, effD2, ueffD2 = [], [], [], [], [], [], [],[]
  for t in timeVec:
      rad_t1 = rad_t0.decay(t, time_unit)
      A_t1 = rad_t1.activities(activity_unit)
      As_t1 = sum(A_t1.values())

      rads = ""; pmf1 = ""
      for key, val in A_t1.items():
          if key != "Pb-208" and key != "Ru-99":
              rads += ', '+key
              pmf1 += ', '+str(val/As_t1)
      rads = rads[2:]
      pmf1 = pmf1[2:]

      out=td.TDCRPy.TDCRPy(L, rads, pmf1, N, kB, V, mode)
      effD.append(out[2]); ueffD.append(out[3]); effT.append(out[4]); ueffT.append(out[5])
      effS.append(out[0]); ueffS.append(out[1]); effD2.append(out[12]); ueffD2.append(out[13])

  effD = np.asarray(effD); effT = np.asarray(effT); ueffD = np.asarray(ueffD); ueffT = np.asarray(ueffT);
  effD2 = np.asarray(effD2); effS = np.asarray(effS); ueffD2 = np.asarray(ueffD2); ueffS = np.asarray(ueffS);
  tdcr = effT/effD
  ```





  ```python

  plt.figure(figsize=(10, 6))
  plt.errorbar(timeVec, effS, yerr=ueffS, fmt='o', capsize=5, label=r'$\epsilon_S$')
  plt.errorbar(timeVec, effD, yerr=ueffD, fmt='o', capsize=5, label=r'$\epsilon_D$')
  plt.errorbar(timeVec, tdcr, yerr=ueffT , fmt='o', capsize=5, label=r'$\epsilon_T/\epsilon_D$')
  plt.errorbar(timeVec, effD2, yerr=ueffD2, fmt='o', capsize=5, label=r'$\epsilon_D$ (CIEMAT/NIST)')



  plt.xlabel(f'cooling time /{time_unit}',fontsize=16)
  plt.ylabel(r'$\epsilon_D$ and $\epsilon_T/\epsilon_D$',fontsize=16)
  plt.legend(fontsize=16)
  plt.grid(True)

  plt.savefig("plotDecay")

  plt.show()
  ```



  ![png](docs/dynamicDecay/output_15_0.png)




  ```python

  ```


pkgId: 94bdf45e1b2f07cf8a2c4699a646de8e06b08d48d42c62a95be368ecc9af2b63
name: python-TEflow-help
arch: noarch
version: 0.4.2
epoch: 0
release: 1
summary: Development documents and examples for TEflow
url: https://github.com/JianboHIT/TEflow
rpm_license: Apache-2.0 license
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-TEflow-0.4.2-1.src.rpm
location_href: Packages/python-TEflow-help-0.4.2-1.noarch.rpm
checksum_type: sha256
description:
  A python3 package for streamlining thermoelectric workflow from materials to devices


  - Model carrier transport
    - Single parabolic band (SPB) model
    - Single Kane band (SKB) model
    - Multiple bands model
    - Customized band model
  - Debye model of lattice thermal conductivity
    - Calculations & Fitting
    - Scattering Mechanisms, e.g., three-phonon, point defects, etc.
    - Bipolar thermal conductivity
  - Engineering performance of thermoelectric generator[^1]
    - Engineering dimensionless figure of merit (ZT<sub>eng</sub>) and power factor (PF<sub>eng</sub>)
    - Maximum Efficiency (η<sub>max</sub>) and ouput power density (P<sub>d</sub>)
    - R<sub>L</sub>- (external electric load resistance) or I- (electric current density) dependent properties, e.g. output voltage (V), heat flux (Q<sub>hot</sub>)
  - Device ZT of thermoelectric generator[^2]
    - Maximum thermoelectric device efficiency
    - Optimized relative current density $u$
    - Thermoelectric potential $\Phi$
  - Thermoelectric data manipulation
    - Thermoelectric data interpolation and extrapolation
    - Cut-off thermoelectric data at the threshold temperature
    - Join and rearrange parallel data files
    - Mix parallel data files with linear combination

  <br/><br/>


  [^1]: Kim, H. S., Liu, W., Chen, G., Chu, C. W., & Ren, Z. (2015). Relationship between thermoelectric figure of merit and energy conversion efficiency.
  _Proceedings of the National Academy of Sciences_, 112(27), 8205-8210. DOI: [10.1073/pnas.1510231112](https://doi.org/10.1073/pnas.1510231112)

  [^2]: Snyder, G. J., & Snyder, A. H. (2017). Figure of merit ZT of a thermoelectric device defined from materials properties.
  _Energy & Environmental Science_, 10(11), 2280-2283. DOI: [10.1039/C7EE02007D](https://doi.org/10.1039/C7EE02007D)


pkgId: 0f49808720ab5b6515b1f2d398b5c1047285478dbe3e66c26688b852f43a198b
name: python-TFBind-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for TFBind
url: https://github.com/jingpengLiu/TFBind
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-TFBind-0.3.0-1.src.rpm
location_href: Packages/python-TFBind-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  Predict whether the transcription factor protein sequence binds to the DNA gene sequence



  TFBind works under Python 3.11.4

  The required dependencies for TFBind are as follows：

  python==3.11.4

  torch==2.0.1

  numpy

  pandas==2.1.1

  scikit-learn


  TFBind Two files are required for input, one is the amino acid protein sequence of the transcription factor, and the other is the DNA nucleotide sequence. The protein sequence does not exceed 1451bp, and the DNA sequence does not exceed 150bp.



  The output is 1 and 0. 1 represents the potential combination possibility in model calculation, and 0 represents the potential non-combination possibility.


pkgId: 645255c69ddd2712cdd614b6cb7f707b1af6c2c88bac33a8fe1b5336bba5170e
name: python-TMC-2209-Raspberry-Pi-help
arch: noarch
version: 0.5.6
epoch: 0
release: 1
summary: Development documents and examples for TMC-2209-Raspberry-Pi
url: https://github.com/Chr157i4n/TMC2209_Raspberry_Pi
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-TMC-2209-Raspberry-Pi-0.5.6-1.src.rpm
location_href: Packages/python-TMC-2209-Raspberry-Pi-help-0.5.6-1.noarch.rpm
checksum_type: sha256
description:
  RPi.GPIO    | RASPBERRY_PI              | Pi4, Pi3 etc.
  gpiozero    | RASPBERRY_PI5             | Pi5
  Jetson.GPIO | NVIDIA_JETSON             | Nvidia Jetson
  pheriphery  | LUCKFOX_PICO              | Luckfox Pico
  pheriphery  | LUCKFOX_PICO              | Luckfox Pico
  OPi.GPIO    | ORANGE_PI                 | Orange Pi
  Those libraries are needed for this library to work. You can either install the correct library yourself.
  You can also install the needed GPIO library by specifing the Installation Parameter while installing this library:
  ```shell
  pip3 install TMC-2209-Raspberry-Pi[RASPBERRY_PI]
  ```

  Pin TMC2209 | connect to | Function
  -- | -- | --
  TX or PDN_UART with 1kOhm | TX of Raspberry Pi | send data to TMC via UART
  RX or PDN_UART directly | RX of Raspberry Pi | receive data from TMC via UART
  VDD | 3,3V of Raspberry Pi | optional, for more stable logic voltage
  GND | GND of Raspberry Pi | GND for VDD and Signals
  VM | 12V or 24V of power supply | power for the motor
  GND | GND of power supply | power for the motor
  EN | GPIO21 of Raspberry Pi | enable the motor output
  STEP | GPIO16 of Raspberry Pi | moves the motor one step per pulse
  DIR | GPIO20 of Raspberry Pi | set the direction of the motor
  DIAG | GPIO26 of Raspberry Pi | optional, for StallGuard
  ![wiring diagram](docs/images/wiring_diagram.png)
  The GPIO pins can be specific when initiating the class.
  If you test this on a breadboard, make sure to cut off the bottomside of the pins (Vref and DIAG) next to the EN pin, so that they are not shorted trough the breadboard.

  You can run the demo scripts files from the main directory with
  ```shell
  python3 -m demo.demo_script_01_uart_connection
  ```

  This only communicates with the TMC driver over UART. It should set some settings in the driver and then outputs the settings.
  When it outputs ```TMC2209: UART Communication Error```, you need to check the UART-connection.

  This script enables the raspberry GPIO output for the dir, en and step pin and then checks the TMC driver register,
  whether the driver sees them as HIGH or LOW. Because the enabled pin is activated for a short time, the motor current ouput
  will be also activated in this script for a short time.
  This script should output:
  Pin DIR:        OK
  Pin STEP:       OK
  Pin EN:         OK
  if not, check the connection of the pin.

  This script should move the motor 6 times, one revolution back and forth.

  In this script the stallguard feature of the TMC2209 is beeing setup.
  A funtion will be called, if the driver detects a stall. The function stops the current movement.
  The motor will be moved 10 revolutions. If the movement is finished unhindered, the script outputs ```Movement finished successfully```.
  If you block the motor with pliers or something similar, the the motor will stop and the script outputs ```StallGuard!``` and ```Movement was not completed```

  VACTUAL allows moving the motor by UART control. It gives the motor velocity in +-(2^23)-1 [μsteps / t]

  Multiple drivers can be addressed via UART by setting different addresses with the MS1 and MS2 pins.
  Simultaneous movement of multiple motors can be done with threaded movement.

  In this script, the movement of a stepper with threads is shown. This can be used to do other task while moving a motor, or to move several motors simultaneous.

  This script shows how you can alter the formatting of the TMC2209 log messages and redirect the log output to a file called `tmc2209_log_file.log` that will be created in the current directory.
  \
  \
  For me these baudrates worked fine: 19200, 38400, 57600, 115200, 230400, 460800, 576000.
  If the TMC2209 driver is connected to the Vmotor, the internal voltage regulator will create the Vio for the chip.
  So you don't need to connect anything to the Vio pin of the driver.

  ```python
  from TMC_2209.TMC_2209_StepperDriver import *
  tmc = TMC_2209(21, 16, 20)
  tmc.set_direction_reg(False)
  tmc.set_current(300)
  tmc.set_interpolation(True)
  tmc.set_spreadcycle(False)
  tmc.set_microstepping_resolution(2)
  tmc.set_internal_rsense(False)
  tmc.set_acceleration(2000)
  tmc.set_max_speed(500)
  tmc.set_motor_enabled(True)
  tmc.run_to_position_steps(400)
  tmc.run_to_position_steps(0)
  tmc.set_motor_enabled(False)
  ```

  If you have questions please check out the [Wiki](https://github.com/Chr157i4n/TMC2209_Raspberry_Pi/wiki) and the other issues.
  If you encounter any problems, feel free to open an issue (ENG/GER).
  Please don't send any E-Mails to me. Pls use Github, so that i don't need to answer the same question multiple times.
  I reserve the right not to answer E-Mails.
  Problem | Solution
  -- | --
  FileNotFoundError: [Errno 2] No such file or directory: '/dev/serial0' | depending on your Raspberry Pi version, you need to enable the Serial Port <br /> run `sudo raspi-config` in your terminal. <br /> there go to '3 Interface Options' -> 'P3 Serial Port' <br /> Would you like a login shell to be accessible over serial? No <br /> Would you like the serial port hardware to be enabled? Yes <br /> Finish and then reboot
  PermissionError: [Errno 13] <br /> Permission denied: '/dev/serial0' | you need to give the permission to acces the Serial Port to your current user <br /> You may need to add your user (pi) to the dialout group with `sudo usermod -a -G dialout pi` and then relog. <br /> If that does not work, make sure that your user has read/write permissions on the dev file `/dev/serial0` by calling `sudo chmod 660 /dev/serial0`.
  "TMC2209: UART Communication Error" | You can use the 'debug_script_01_uart_connection' script to get a better reading on the received bytes and troubleshoot your problem
  "TMC2209: UART Communication Error: 0 data bytes \| 4 total bytes" | only 4 total bytes received indicates, that the Raspberry Pi receives its own data, but nothing from the TMC driver. This happens if RX and TX are connected properly, but the TMC driver has no power
  "TMC2209: UART Communication Error: 0 data bytes \| 0 total bytes" | 0 total bytes received indicates, a problem with your wiring or your Raspberry Pi. This happens if TX is not connected
  "TMC2209: UART Communication Error: 4 data bytes \| 12 total bytes" | this indicates, the Raspberry Pi received only zeroes. This happens if only RX is connected and TX not
  "the Raspberry Pi received only the sended bits" or<br /> inconsistent received bits | Make sure the UART ist properly connected to the TMC driver and the driver is powered and working. <br /> Make sure login shell (console) over serial is disabled.
  ![wiring photo](docs/images/wiring_photo.jpg)

  The code to run the stepper motor is based on the code of the [AccelStepper Library from Mike McCauley](http://www.airspayce.com/mikem/arduino/AccelStepper).
  The code for the UART communication is based on this [code from troxel](https://github.com/troxel/TMC_UART).
  My goal is to make a library, that can run a stepper motor with a TMC2209 stepper driver and can write the setting in the register of the TMC2209, entirely in Python.
  The main focus for this are Test setups, as Python is not fast enough for high motor speeds.

  If you encounter any problem, feel free to open an issue on the Github [issue page](https://github.com/Chr157i4n/TMC2209_Raspberry_Pi/issues).
  Feedback will keep this project growing and I encourage all suggestions.
  Feel free to submit a pull request on the dev branch.


pkgId: 3d8dcfb51f636e42db472de860aedd9716b7ec8e56b6fb9a717665c00b8ae4ae
name: python-TMDBTraktSyncer-help
arch: noarch
version: 1.7.3
epoch: 0
release: 1
summary: Development documents and examples for TMDBTraktSyncer
url: https://github.com/RileyXX/TMDB-Trakt-Syncer
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-TMDBTraktSyncer-1.7.3-1.src.rpm
location_href: Packages/python-TMDBTraktSyncer-help-1.7.3-1.noarch.rpm
checksum_type: sha256
description:
  This Python script syncs user watchlist and ratings for Movies, TV Shows, and Episodes both ways between [Trakt](https://trakt.tv/) and [TMDB](https://www.themoviedb.org/). Data already set will not be overwritten. Ratings and watchlist sync are both optional. The user will be prompted to enter their settings and api keys on first run.

  The script is compatible on any operating system that supports Python v3.6 or later, including Windows, Linux, Mac, and ChromeOS. If you're interested in syncing ratings between Trakt, Plex, IMDB, and TMDB, I recommend the following projects: [PlexTraktSync](https://github.com/Taxel/PlexTraktSync), [IMDB-Trakt-Syncer](https://github.com/RileyXX/IMDB-Trakt-Syncer), and [TMDB-Trakt-Syncer](https://github.com/RileyXX/TMDB-Trakt-Syncer). See below for my other [recommended projects](https://github.com/RileyXX/TMDB-Trakt-Syncer?tab=readme-ov-file#other-recommended-projects).


  1. Install [Python](https://www.python.org/downloads/) (v3.6 or later). During installation, tick the box for adding Python to your PATH variable.
  2. Install the script by running `python -m pip install TMDBTraktSyncer` in command line.
  3. Login to [Trakt](https://trakt.tv/oauth/applications) and create a new API application named `TMDbTraktSyncer`. In the "Redirect uri" field, enter `urn:ietf:wg:oauth:2.0:oob`, then save the application.
  4. Login to [TMDB](https://www.themoviedb.org/settings/api/) and create a new API application. Choose "Developer" and accept the terms. Fill out the application form as follows:
     - Type of use: `Personal`
     - Application name: `TMDB-Trakt-Sync`
     - Application URL: `https://github.com/RileyXX/TMDB-Trakt-Syncer`
     - Application summary: `Use TMDB API and Trakt API to sync user watchlists and ratings between platforms.`
     - Fill in the rest of the fields as desired and submit the form. Your API keys will be generated instantly.
  5. Run the script by running `TMDBTraktSyncer` in the command line.
  6. Follow the prompts during the first run. You will need to enter your Trakt `client ID` and `client secret` from step 3, as well as your `tmdb_v4_token` from step 4. Please note that these details are saved insecurely as `credentials.txt` in the same folder as the script.
  7. Setup is complete. The script will continue running and syncing your ratings. You can monitor its progress in the command line. See below for [setting up automation](https://github.com/RileyXX/TMDB-Trakt-Syncer?tab=readme-ov-file#for-setting-up-automation-see-the-following-wiki-pages).


  ```
  python -m pip install TMDBTraktSyncer
  ```
  _Run in your operating system's native command line._

  ```
  TMDBTraktSyncer
  ```
  _Run in your operating system's native command line._

  ```
  python -m pip install TMDBTraktSyncer --upgrade
  ```
  _Run in your operating system's native command line._

  ```
  python -m pip uninstall TMDBTraktSyncer
  ```
  _Run in your operating system's native command line._


  ```
  python -m pip install TMDBTraktSyncer==VERSION_NUMBER
  ```
  _Replace `VERSION_NUMBER` with your [desired version](https://github.com/RileyXX/TMDB-Trakt-Syncer/releases) (e.g. 1.0.1) and run in your operating system's native command line._


  1. Install [Python](https://www.python.org/downloads/) (v3.6 or later). During installation, tick the box for adding Python to your PATH variable.
  2. Download the latest .zip from the [releases page](https://github.com/RileyXX/TMDB-Trakt-Syncer/releases) and extract it to the desired directory.
  3. Login to [Trakt](https://trakt.tv/oauth/applications) and create a new API application named `TMDBTraktSyncer`. In the "Redirect uri" field, enter `urn:ietf:wg:oauth:2.0:oob`, then save the application.
  4. Login to [TMDB](https://www.themoviedb.org/settings/api/) and create a new API application. Choose "Developer" and accept the terms. Fill out the application form as follows:
     - Type of use: `Personal`
     - Application name: `TMDB-Trakt-Sync`
     - Application URL: `https://github.com/RileyXX/TMDB-Trakt-Syncer`
     - Application summary: `Use TMDB API and Trakt API to sync user watchlists and ratings between platforms.`
     - Fill in the rest of the fields as desired and submit the form. Your API keys will be generated instantly.
  5. Run `TMDBTraktSyncer.py` or open the terminal and navigate to the folder where `TMDBTraktSyncer.py` is located, then run `TMDBTraktSyncer.py` in the terminal.
  6. Follow the prompts during the first run. You will need to enter your Trakt `client ID` and `client secret` from step 3, as well as your `tmdb_v4_token` from step 4. Please note that these details are saved insecurely as `credentials.txt` in the same folder as the script.
  7. Setup is complete. The script will continue running and syncing your ratings. You can monitor its progress in the command line. See below for [setting up automation](https://github.com/RileyXX/TMDB-Trakt-Syncer#for-setting-up-automation-see-the-following-wiki-pages).


  - Setup Automation for:
     - [Windows](https://github.com/RileyXX/TMDB-Trakt-Syncer/wiki/Setting-Up-Automation-on-Windows)
     - [Linux](https://github.com/RileyXX/TMDB-Trakt-Syncer/wiki/Setting-Up-Automation-on-Linux)
     - [macOS](https://github.com/RileyXX/TMDB-Trakt-Syncer/wiki/Setting-Up-Automation-on-macOS)
  - Python Script to Update all Packages with Pip (Windows, Linux, Mac, ChromeOS, etc.) [Link #1](https://github.com/RileyXX/TMDB-Trakt-Syncer/wiki/Python-Script-to-Update-all-Packages-with-Pip-\(Windows,-Linux,-Mac,-ChromeOS,-etc\))


  * If any of your details change (passwords, logins, API keys, etc.), simply open `credentials.txt`, modify your details, save it and then run the script again. Alternatively, delete `credentials.txt` to reset the script and it will prompt you to enter your new details on the next run.
  * Add support for review/comment sync [Issue #1](https://github.com/RileyXX/TMDB-Trakt-Syncer/issues/1)


  ![Demo](https://i.imgur.com/5LI04O2.png)


  If you find my scripts helpful, you can become a [sponsor](https://github.com/sponsors/RileyXX) and support my projects! If you need help with a project, open an issue, and I'll do my best to assist you. For other inquiries and custom projects, you can contact me on [Twitter](https://twitter.com/RileyxBell).


  - Cashapp: [$rileyxx](https://cash.app/$rileyxx/)
  - Venmo: [@rileyxx](https://account.venmo.com/u/rileyxx)
  - Bitcoin: `bc1qrjevwqv49z8y77len3azqfghxrjmrjvhy5zqau`


  * [PyPi](https://pypi.org/project/TMDBTraktSyncer/)
  * [Reddit](https://www.reddit.com/r/trakt/comments/13jlu4r/tmdb_trakt_rating_syncer_tool_2_way_sync/)

  <br>

  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)



  | Project Name | Description |
  |--------------|-------------|
  | [PlexTraktSync](https://github.com/Taxel/PlexTraktSync) | A script that syncs user watch history and ratings between Trakt and Plex (without needing a PlexPass or Trakt VIP subscription). |
  | [IMDB-Trakt-Syncer](https://github.com/RileyXX/IMDB-Trakt-Syncer) | A script that syncs user watchlist, ratings, and reviews both ways between Trakt and IMDB. |
  | [TMDB-Trakt-Syncer](https://github.com/RileyXX/TMDB-Trakt-Syncer) | A script that syncs user watchlist and ratings both ways between Trakt and TMDB. |
  | [PlexPreferNonForcedSubs](https://github.com/RileyXX/PlexPreferNonForcedSubs) | A script that sets all movies and shows in your local Plex library to English non-forced subtitles by default. |
  | [Casvt / AudioSubChanger](https://github.com/Casvt/Plex-scripts/blob/main/media_management/audio_sub_changer.py) | A script with advanced options for changing audio & subtitle tracks in Plex. |
  | [Casvt / PlexAutoDelete](https://github.com/Casvt/Plex-scripts/blob/main/media_management/plex_auto_delete.py) | A script for automatically deleting watched content from Plex. |
  | [universal-trakt-scrobbler](https://github.com/trakt-tools/universal-trakt-scrobbler) | An extension that automatically scrobbles TV shows and Movies from several streaming services to Trakt. |
  | [Netflix-to-Trakt-Import](https://github.com/jensb89/Netflix-to-Trakt-Import) | A tool to import your Netflix viewing history into Trakt. |
  | [trakt-tv-backup](https://darekkay.com/blog/trakt-tv-backup/) | A command-line tool for backing up your Trakt.tv data. |
  | [blacktwin / JBOPS](https://github.com/blacktwin/JBOPS) | A collection of scripts and tools for enhancing and automating tasks in Plex. |
  | [Casvt / Plex-scripts](https://github.com/Casvt/Plex-scripts) | A collection of useful scripts for Plex automation and management. |
  | [trakt---letterboxd-import](https://github.com/jensb89/trakt---letterboxd-import) | A tool to import your Letterboxd ratings and watchlist into Trakt. |
  | [TraktRater](https://github.com/damienhaynes/TraktRater/) | A tool to help users transfer user episode, show, and movie user ratings and watchlists from multiple media database sites around the web. |
  | [TvTimeToTrakt](https://github.com/lukearran/TvTimeToTrakt) | A tool to sync your TV Time watch history with Trakt.tv. |
  | [Plex Media Server](https://www.plex.tv/media-server-downloads/#plex-app) | A media server software to organize and stream your personal media collection. |
  | [Radarr](https://github.com/Radarr/Radarr) | A movie collection manager and downloader for various platforms. |
  | [Sonarr](https://github.com/Sonarr/Sonarr) | A TV show collection manager and downloader for various platforms. |
  | [Jackett](https://github.com/Jackett/Jackett) | A proxy server that provides API support for various torrent trackers commonly used with Radarr and Sonarr. |
  | [qBittorrent](https://github.com/qbittorrent/qBittorrent) | A free and open-source BitTorrent client. |
  | [AirVPN](https://airvpn.org/) | A VPN client with port forwarding support. Great VPN for torrents. |
  | [Overseerr](https://github.com/sct/overseerr) | A request management and media discovery tool for your home media server. |
  | [FlareSolverr](https://github.com/FlareSolverr/FlareSolverr) | A reverse proxy solution to bypass Cloudflare protection and access websites commonly used with Jackett. |
  | [yt-dlp](https://github.com/yt-dlp/yt-dlp) | A command-line program to download videos from YouTube and other sites. |


pkgId: 74d04d0b8f8ab1793094f3a053c2bc2a26a181b3907b421577ac0642950cb2de
name: python-Tailbone-help
arch: noarch
version: 0.22.5
epoch: 0
release: 1
summary: Development documents and examples for Tailbone
url: https://rattailproject.org
rpm_license: GNU GPL v3+
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Tailbone-0.22.5-1.src.rpm
location_href: Packages/python-Tailbone-help-0.22.5-1.noarch.rpm
checksum_type: sha256
description:
  Tailbone is an extensible web application based on Rattail.  It provides a
  "back-office network environment" (BONE) for use in managing retail data.

  Please see Rattail's [home page](http://rattailproject.org/) for more
  information.


pkgId: 7ed6ba0ae00b8e5f1300760a0d817136f8afb2212145d452e14c968eb5113891
name: python-TezzCrawler-help
arch: noarch
version: 0.3.1
epoch: 0
release: 1
summary: Development documents and examples for TezzCrawler
url: https://github.com/TezzLabs/TezzCrawler
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-TezzCrawler-0.3.1-1.src.rpm
location_href: Packages/python-TezzCrawler-help-0.3.1-1.noarch.rpm
checksum_type: sha256
description:
  A powerful web crawler that converts web pages to markdown format, making them ready for LLM consumption.



  - Single page scraping with markdown conversion
  - Full website crawling using sitemap.xml
  - Proxy support for web scraping
  - Simple CLI interface
  - Easy to use as a Python package



  ```bash
  pip install TezzCrawler
  ```





  1. Scrape a single page:
  ```bash
  tezzcrawler scrape-page https://example.com --output ./output
  ```

  2. Crawl from sitemap:
  ```bash
  tezzcrawler crawl-from-sitemap https://example.com/sitemap.xml --output ./output
  ```

  3. Using with proxy:
  ```bash
  tezzcrawler scrape-page https://example.com \
      --proxy-url proxy.example.com \
      --proxy-port 8080 \
      --proxy-username user \
      --proxy-password pass \
      --output ./output
  ```



  ```python
  from tezzcrawler import Scraper, Crawler
  from pathlib import Path


  scraper = Scraper()
  scraper.scrape_page("https://example.com", Path("./output"))


  crawler = Crawler()
  crawler.crawl_sitemap("https://example.com/sitemap.xml", Path("./output"))


  scraper = Scraper(
      proxy_url="proxy.example.com",
      proxy_port=8080,
      proxy_username="user",
      proxy_password="pass"
  )
  ```



  1. Clone the repository:
  ```bash
  git clone https://github.com/TezzLabs/TezzCrawler.git
  cd TezzCrawler
  ```

  2. Install development dependencies:
  ```bash
  pip install -e ".[dev]"
  ```



  MIT License - see LICENSE file for details.


pkgId: aeaeaa2447880d76150dd74b94a5aa3988be9a9cb05942af0b10252047afd746
name: python-TikTokLive-help
arch: noarch
version: 6.2.1.post1
epoch: 0
release: 1
summary: Development documents and examples for TikTokLive
url: https://github.com/isaackogan/TikTokLive
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-TikTokLive-6.2.1.post1-1.src.rpm
location_href: Packages/python-TikTokLive-help-6.2.1.post1-1.noarch.rpm
checksum_type: sha256
description:
  This is an unofficial API wrapper for TikTok LIVE written in Python. With this API you can connect to any TikTok livestream and fetch all data available to users in a stream using just a creator's `@username`.
  [![LinkedIn](https://img.shields.io/badge/LinkedIn-0077B5?style=for-the-badge&logo=linkedin&logoColor=white&style=flat-square)](https://www.linkedin.com/in/isaackogan/)
  [![LinkedIn](https://www.eulerstream.com/api/pips/patrons?v=002)](https://www.eulerstream.com/)
  ![Connections](https://tiktok.eulerstream.com/analytics/pips/1)
  ![Downloads](https://pepy.tech/badge/tiktoklive)
  ![Stars](https://img.shields.io/github/stars/isaackogan/TikTokLive?style=flat&color=0274b5)
  ![Forks](https://img.shields.io/github/forks/isaackogan/TikTokLive?style=flat&color=0274b5)
  ![Issues](https://img.shields.io/github/issues/isaackogan/TikTokLive)
  <!-- [![HitCount](https://hits.dwyl.com/isaackogan/TikTokLive.svg?style=flat)](http://hits.dwyl.com/isaackogan/TikTokLive) -->
  This API is designed to **retrieve** information from TikTok. It **cannot** be used to **post/upload** LIVE content or comments, to simulate user interaction, or otherwise generate fake traffic. This API does **not** count towards viewers
  in a stream. It has **no support** for any **user-authenticated routes**.

  <table>
  <tr>
      <td><br/><img width="180px" style="border-radius: 10px" src="https://raw.githubusercontent.com/isaackogan/TikTokLive/master/.github/SquareLogo.png"><br/><br/></td>
      <td>
          <a href="https://www.eulerstream.com">
              <strong>Euler Stream</strong> is a paid TikTok LIVE service providing managed TikTok LIVE WebSocket connections, increased access, TikTok LIVE alerts, JWT authentication and more.
          </a>
      </td>
  </tr>
  </table>

  <p align="center">
    <a href="https://star-history.com/#danny-avila/LibreChat&Date">
      <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=isaackogan/TikTokLive&type=Date&theme=dark" onerror="this.src='https://api.star-history.com/svg?repos=isaackogan/TikTokLive&type=Date'" />
    </a>
  </p>

  - [Getting Started](#getting-started)
      - [Parameters](#parameters)
      - [Methods](#methods)
      - [Properties](#properties)
      - [WebDefaults](#webdefaults)
  - [Documentation](https://isaackogan.github.io/TikTokLive/)
  - [Other Languages](#other-languages)
  - [Community](#community)
  - [Examples](https://github.com/isaackogan/TikTokLive/tree/master/examples)
  - [Licensing](#license)
  - [Contributors](#contributors)

  Join the [TikTokLive discord](https://discord.gg/e2XwPNTBBr) and visit
  the [`#py-support`](https://discord.gg/uja6SajDxd)
  channel for questions, contributions and ideas.

  1. Install the module via pip from the [PyPi](https://pypi.org/project/TikTokLive/) repository
  ```shell script
  pip install TikTokLive
  ```
  2. Create your first chat connection
  ```python
  from TikTokLive import TikTokLiveClient
  from TikTokLive.events import ConnectEvent, CommentEvent

  client: TikTokLiveClient = TikTokLiveClient(unique_id="@isaackogz")

  @client.on(ConnectEvent)
  async def on_connect(event: ConnectEvent):
      print(f"Connected to @{event.unique_id} (Room ID: {client.room_id}")

  async def on_comment(event: CommentEvent) -> None:
      print(f"{event.user.nickname} -> {event.comment}")
  client.add_listener(CommentEvent, on_comment)
  if __name__ == '__main__':
      
      
      client.run()
  ```
  For more quickstart examples, see the [examples folder](https://github.com/isaackogan/TikTokLive/tree/master/examples)
  provided in the source tree.

  TikTokLive is available in several alternate programming languages:
  - **Node.JS:** [https://github.com/zerodytrash/TikTok-Live-Connector](https://github.com/zerodytrash/TikTok-Live-Connector)
  - **Java:** [https://github.com/jwdeveloper/TikTok-Live-Java](https://github.com/jwdeveloper/TikTok-Live-Java)
  - **C#/Unity:** [https://github.com/frankvHoof93/TikTokLiveSharp](https://github.com/frankvHoof93/TikTokLiveSharp)
  - **Go:** [https://github.com/steampoweredtaco/gotiktoklive](https://github.com/steampoweredtaco/gotiktoklive)
  - **Rust:** [https://github.com/jwdeveloper/TikTokLiveRust](https://github.com/jwdeveloper/TikTokLiveRust)

  | Param Name | Required | Default | Description                                                                                                                                                                                                               |
  |------------|----------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | unique_id  | Yes      | N/A     | The unique username of the broadcaster. You can find this name in the URL of the user. For example, the `unique_id` for [`https://www.tiktok.com/@isaackogz`](https://www.tiktok.com/@isaackogz) would be `isaackogz`.    |
  | web_proxy  | No       | `None`  | TikTokLive supports proxying HTTP requests. This parameter accepts an `httpx.Proxy`. Note that if you do use a proxy you may be subject to reduced connection limits at times of high load.                               |
  | ws_proxy   | No       | `None`  | TikTokLive supports proxying the websocket connection. This parameter accepts an `httpx.Proxy`. Using this proxy will never be subject to reduced connection limits.                                                      |
  | web_kwargs | No       | `{}`    | Under the scenes, the TikTokLive HTTP client uses the [`httpx`](https://github.com/encode/httpx) library. Arguments passed to `web_kwargs` will be forward the the underlying HTTP client.                                |
  | ws_kwargs  | No       | `{}`    | Under the scenes, TikTokLive uses the [`websockets`](https://github.com/python-websockets/websockets) library to connect to TikTok. Arguments passed to `ws_kwargs` will be forwarded to the underlying WebSocket client. |

  A `TikTokLiveClient` object contains the following important methods:
  | Method Name  | Notes   | Description                                                                                                                                                                     |
  |--------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | run          | N/A     | Connect to the livestream and block the main thread. This is best for small scripts.                                                                                            |
  | add_listener | N/A     | Adds an *asynchronous* listener function (or, you can decorate a function with `@client.on(<event>)`) and takes two parameters, an event name and the payload, an AbstractEvent ||
  | connect      | `async` | Connects to the tiktok live chat while blocking the current future. When the connection ends (e.g. livestream is over), the future is released.                                 |
  | start        | `async` | Connects to the live chat without blocking the main thread. This returns an `asyncio.Task` object with the client loop.                                                         |
  | disconnect   | `async` | Disconnects the client from the websocket gracefully, processing remaining events before ending the client loop.                                                                |

  A `TikTokLiveClient` object contains the following important properties:
  | Attribute Name | Description                                                                                                                                                 |
  |----------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------|
  | room_id        | The Room ID of the livestream room the client is currently connected to.                                                                                    |
  | web            | The TikTok HTTP client. This client has a lot of useful routes you should explore!                                                                          |
  | connected      | Whether you are currently connected to the livestream.                                                                                                      |
  | logger         | The internal logger used by TikTokLive. You can use `client.logger.setLevel(...)` method to enable client debug.                                            |
  | room_info      | Room information that is retrieved from TikTok when you use a connection method (e.g. `client.connect`) with the keyword argument `fetch_room_info=True` .  |
  | gift_info      | Extra gift information that is retrieved from TikTok when you use a connection method (e.g. `client.run`) with the keyword argument `fetch_gift_info=True`. |

  TikTokLive has a series of global defaults used to create the HTTP client which you can customize. For info on how to set these parameters, see
  the [web_defaults.py](https://github.com/isaackogan/TikTokLive/blob/master/examples/web_defaults.py) example.
  | Parameter           | Type   | Description                                                                                            |
  |---------------------|--------|--------------------------------------------------------------------------------------------------------|
  | tiktok_app_url      | `str`  | The TikTok app URL (`https://www.tiktok.com`) used to scrape the room.                                 |
  | tiktok_sign_url     | `str`  | The [signature server](https://www.eulerstream.com/) used to generate tokens to connect to TikTokLive. |
  | tiktok_webcast_url  | `str`  | The TikTok livestream URL (`https://webcast.tiktok.com`) where livestreams can be accessed from.       |
  | client_params       | `dict` | The URL parameters added on to TikTok requests from the HTTP client.                                   |
  | client_ws_params    | `dict` | The URL parameters added to the URI when connecting to TikTok's Webcast WebSocket server.              |
  | client_headers      | `dict` | The headers added on to TikTok requests from the HTTP client.                                          |
  | tiktok_sign_api_key | `str`  | A global way of setting the `sign_api_key` parameter.                                                  |

  Events can be listened to using a decorator or non-decorator method call. The following examples illustrate how you can listen to an event:
  ```python
  @client.on(LikeEvent)
  async def on_like(event: LikeEvent) -> None:
  async def on_comment(event: CommentEvent) -> None:
  client.add_listener(CommentEvent, on_comment)
  ```
  There are two types of events, [`CustomEvent`](https://github.com/isaackogan/TikTokLive/blob/master/TikTokLive/events/custom_events.py)
  events and [`ProtoEvent`](https://github.com/isaackogan/TikTokLive/blob/master/TikTokLive/events/proto_events.py) events.
  Both belong to the TikTokLive `Event` type and can be listened to. The following events are available:

  - `ConnectEvent` - Triggered when the Webcast connection is initiated
  - `DisconnectEvent` - Triggered when the Webcast connection closes (including the livestream ending)
  - `LiveEndEvent` - Triggered when the livestream ends
  - `LivePauseEvent` - Triggered when the livestream is paused
  - `LiveUnpauseEvent` - Triggered when the livestream is unpaused
  - `FollowEvent` - Triggered when a user in the livestream follows the streamer
  - `ShareEvent` - Triggered when a user shares the livestream
  - `WebsocketResponseEvent` - Triggered when any event is received (contains the event)
  - `UnknownEvent` - An instance of `WebsocketResponseEvent` thrown whenever an event does not have an existing definition, useful for debugging

  If you know what an event does, [make a pull request](https://github.com/isaackogan/TikTokLive/pulls) and add the description.
  - `GiftEvent` - Triggered when a gift is sent to the streamer
  - `GoalUpdateEvent` - Triggered when the subscriber goal is updated
  - `ControlEvent` - Triggered when a stream action occurs (e.g. Livestream start, end)
  - `LikeEvent` - Triggered when the stream receives a like
  - `SubscribeEvent` - Triggered when someone subscribes to the TikTok creator
  - `PollEvent` - Triggered when the creator launches a new poll
  - `CommentEvent` - Triggered when a comment is sent in the stream
  - `RoomEvent` - Messages broadcasted to all users in the room (e.g. "Welcome to TikTok LIVE!")
  - `EmoteChatEvent` - Triggered when a custom emote is sent in the chat
  - `EnvelopeEvent` - Triggered every time someone sends a treasure chest
  - `SocialEvent` - Triggered when a user shares the stream or follows the host
  - `QuestionNewEvent` - Triggered every time someone asks a new question via the question feature.
  - `LiveIntroEvent` - Triggered when a live intro message appears
  - `LinkMicArmiesEvent` - Triggered when a TikTok battle user receives points
  - `LinkMicBattleEvent` - Triggered when a TikTok battle is started
  - `JoinEvent` - Triggered when a user joins the livestream
  - `LinkMicFanTicketMethodEvent`
  - `LinkMicMethodEvent`
  - `BarrageEvent`
  - `CaptionEvent`
  - `ImDeleteEvent`
  - `RoomUserSeqEvent` - Current viewer count information
  - `RankUpdateEvent`
  - `RankTextEvent`
  - `HourlyRankEvent`
  - `UnauthorizedMemberEvent`
  - `MessageDetectEvent`
  - `OecLiveShoppingEvent`
  - `RoomPinEvent`
  - `SystemEvent`
  - `LinkEvent`
  - `LinkLayerEvent`


  Triggered every time a gift arrives. Extra information can be gleamed from the `available_gifts` client attribute.
  > **NOTE:** Users have the capability to send gifts in a streak. This increases the `event.gift.repeat_count` value until the
  > user terminates the streak. During this time new gift events are triggered again and again with an
  > increased `event.gift.repeat_count` value. It should be noted that after the end of a streak, a final gift event is
  > triggered, which signals the end of the streak with `event.repeat_end`:`1`. The following handlers show how you can deal with this in your code.
  Using the low-level direct proto:
  ```python
  @client.on(GiftEvent)
  async def on_gift(event: GiftEvent):
      
      if event.gift.info.type == 1:
          if event.gift.is_repeating == 1:
              print(f"{event.user.unique_id} sent {event.repeat_count}x \"{event.gift.name}\"")
      
      elif event.gift.info.type != 1:
          print(f"{event.user.unique_id} sent \"{event.gift.name}\"")
  ```
  Using the TikTokLive extended proto:
  ```python
  @client.on("gift")
  async def on_gift(event: GiftEvent):
      
      if event.gift.streakable and not event.streaking:
          print(f"{event.user.unique_id} sent {event.repeat_count}x \"{event.gift.name}\"")
      
      elif not event.gift.streakable:
          print(f"{event.user.unique_id} sent \"{event.gift.name}\"")
  ```

  This event will only fire when a session ID (account login) is passed to the HTTP client *before* connecting to TikTok LIVE.
  You can set the session ID with [`client.web.set_session_id(...)`](https://github.com/isaackogan/TikTokLive/blob/master/examples/logged_in.py).

  It is considered inefficient to use the connect method to check if a user is live. It is better to use the dedicated `await client.is_live()` method.
  There is a [complete example](https://github.com/isaackogan/TikTokLive/blob/master/examples/check_live.py) of how to do this in the [examples](https://github.com/isaackogan/TikTokLive/tree/master/examples) folder.

  * **Isaac Kogan** - *Creator, Primary Maintainer, and Reverse-Engineering* - [isaackogan](https://github.com/isaackogan)
  * **Zerody** - *Initial Reverse-Engineering Protobuf & Support* - [Zerody](https://github.com/zerodytrash/)
  * **Davincible** - *Reverse-Engineering Stream Downloads*  - [davincible](https://github.com/davincible)
  See also the full list of [contributors](https://github.com/isaackogan/TikTokLive/contributors) who have participated in
  this project.

  This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.


pkgId: ebffcc3c9e9894c10115c935ac86009120508a672a886491f0509b8bc0f6b11f
name: python-Toffy-help
arch: noarch
version: 0.3.0
epoch: 0
release: 1
summary: Development documents and examples for Toffy
url: https://github.com/angelolab/toffy
rpm_license: Modified Apache 2.0
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Toffy-0.3.0-1.src.rpm
location_href: Packages/python-Toffy-help-0.3.0-1.noarch.rpm
checksum_type: sha256
description:
  <div align="center">

  | | |
  | ---        |    ---  |
  | CI / CD | [![CI](https://github.com/angelolab/toffy/actions/workflows/ci.yml/badge.svg)](https://github.com/angelolab/toffy/actions/workflows/ci.yml) [![Coverage Status](https://coveralls.io/repos/github/angelolab/toffy/badge.svg?branch=main)](https://coveralls.io/github/angelolab/mibi-bin-tools?branch=main) |
  | Package | [![PyPI - Version](https://img.shields.io/pypi/v/toffy.svg?logo=pypi&label=PyPI&logoColor=gold)](https://pypi.org/project/toffy/) [![PyPI - Downloads](https://img.shields.io/pypi/dm/toffy.svg?color=blue&label=Downloads&logo=pypi&logoColor=gold)](https://pypi.org/project/toffy/) [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/toffy.svg?logo=python&label=Python&logoColor=gold)](https://pypi.org/project/toffy/) |
  |Meta | [![code style - Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) [![types - Mypy](https://img.shields.io/badge/types-Mypy-blue.svg)](https://github.com/python/mypy) [![PyPI - License](https://img.shields.io/pypi/l/toffy?color=9400d3)](LICENSE) |
  </div>


  The `toffy` repo is designed to simplify the process of generating and processing data on the MIBIScope platform.

  This repo is currently in beta testing. None of the code has been published yet, and we will be making breaking changes frequently. If you find bugs, please [open an issue](https://github.com/angelolab/toffy/issues/new/choose).


  - [Overview](#overview)
    - [1. Using toffy for the first time](#1-using-toffy-for-the-first-time)
    - [2. Setting up a MIBI run](#2-setting-up-a-mibi-run)
    - [3. Evaluating a MIBI run](#3-evaluating-a-mibi-run)
    - [4. Processing After a MIBI run](#4-processing-after-a-mibi-run)
    - [5. Formatting MIBI Data for Downstream Analysis](#5-formatting-mibi-data-for-downstream-analysis)
  - [Pipeline Flowchart](#pipeline-flowchart)
  - [Installation](#installation)
    - [Requirements for specific operating systems](#requirements-for-specific-operating-systems)
      - [Windows](#windows)
      - [macOS](#macos)
    - [Setting up the virtual environment](#setting-up-the-virtual-environment)
    - [Using the repo](#using-the-repo)
    - [Updating the repo](#updating-the-repo)
  - [Directory structure](#directory-structure)
  - [Panel format](#panel-format)
  - [Median Pulse Height](#median-pulse-height)
  - [Development Notes](#development-notes)
    - [Requirements](#requirements)
    - [Setup](#setup)
  - [Questions?](#questions)
  - [How to cite](#how-to-cite)


  The repo has four main parts, with associated code and jupyter notebooks for each.
  We have also recorded workshop talks which complement the repository. [MIBI Workshop (Pre-Recorded Lectures) Playlist](https://www.youtube.com/playlist?list=PLjNbkEm4vA27f8-EB7q9u_lDPI7oxohhn).


  The first time you use toffy on one of the commercial instruments, you'll need to perform some basic tasks to ensure everything is working properly. The [set up](./templates/1_set_up_toffy.ipynb) jupyter notebook will guide you through this process and the resulting directory structure is explained below ([directory structure](#directory-structure)).
  For more information, see the [setup toffy walkthrough](https://youtu.be/ZEtqSptJP1M).


  For large MIBI runs, it is often convenient to automatically generate the JSON file containing the individual FOVs. There are two notebooks for this task, one for large tiled regions, the second for TMAs. If you will be tiling multiple adjacent FOVs together into a single image, the [tiling](./templates/2_create_tiled_mibi_run.ipynb) notebook can automate this process. You provide the location of the top corner of the tiled region, along with the number of fovs along the rows and columns, and it will automatically create the appropriate JSON file.

  The [second notebook](./templates/2_create_tma_mibi_run.ipynb) is for TMAs. This notebook is run after you have selected the appropriate cores from the TMA. It will generate an overlay with the image of the TMA and the locations you picked to ensure you selected the correct cores. It will then check that they are named correctly and that there are no duplicates.

  For more information, see the [MIBI tiling walkthrough](https://www.youtube.com/watch?v=U0C_nMT9CBQ&list=PLjNbkEm4vA27f8-EB7q9u_lDPI7oxohhn&index=2).



  There are a number of different computational tasks to complete once a MIBI run has finished to ensure everything went smoothly.

  - 3a: real time monitoring. The [MIBI monitoring](./templates/3a_monitor_MIBI_run.ipynb) notebook will monitor an ongoing MIBI run, and begin processing the image data as soon as it is generated. This notebook is being continually be updated as we move more of our processing pipeline to happen in real time as the data is generated.
  For more information, see the [real-time monitoring walkthrough](https://www.youtube.com/watch?v=o1nHJ5dGcTQ&list=PLjNbkEm4vA27f8-EB7q9u_lDPI7oxohhn&index=4).
  - 3b - 3e: post-run monitoring. For each step in the monitoring notebook, we have a dedicated notebook that can perform the same tasks once a run is complete.
  For more information, see the [image processing and extraction walkthrough](https://www.youtube.com/watch?v=QSzjW-cuZtg&list=PLjNbkEm4vA27f8-EB7q9u_lDPI7oxohhn&index=3).
    - 3b: [image extraction notebook](./templates/3b_extract_images_from_bin.ipynb) will extract images from bin files that have not already been processed
    - 3c: [qc metrics notebook](./templates/3c_generate_qc_metrics.ipynb) computes and visualizes the QC metrics for the images
    - 3d: [median pulse heights notebook](./templates/3d_compute_median_pulse_height.ipynb) generates plots showing median pulse heights for each FOV, along with estimated run time
    - 3e: [stitch images notebook](./templates/3e_stitch_images.ipynb) creates a single stitched image for each channel in your panel across all of the FOVs in your run


  Once your run has finished, you can begin to process the data to make it ready for analysis. To remove background signal contamination, as well as compensate for channel crosstalk, you can use the [compensation](./templates/4a_compensate_image_data.ipynb) notebook. This will guide you through the Rosetta algorithm, which uses a flow-cytometry style compensation approach to remove spurious signal.

  Following compensation, you will want to normalize your images to ensure consistent intensity across the run. You can use the [normalization](./templates/4b_normalize_image_data.ipynb) notebook to perform this step.


  After the image processing and cleanup from *toffy* is complete, the final step is to format your data to faciliate easy downstream analysis. The [reorganization](./templates/5_rename_and_reorganize.ipynb) notebook will walk you through the process of renaming FOVs, combining partial runs, and consolidating your images.
  For more information, see the [reorganizing your data walkthrough](https://www.youtube.com/watch?v=nKYGWQ7GXC4&list=PLjNbkEm4vA27f8-EB7q9u_lDPI7oxohhn&index=5).



  ![flow-chart](templates/img/toffy_processing.png)


  In order to get `toffy` working, you'll need to first install some dependencies and the repository itself. For more information, see the [toffy setup walkthrough](https://www.youtube.com/watch?v=g52-oqP_QjA&list=PLjNbkEm4vA27f8-EB7q9u_lDPI7oxohhn&index=1)


  The process of setting up is largely the same for different operating systems. However, there are a few key differences.



  - You must have **C++ Build Tools** (VS19) installed.
  Go to  https://visualstudio.microsoft.com/visual-cpp-build-tools/ and click 'Download Build Tools'.
  Open the installer and make sure you are installing the package labeled *C++ build tools*, then follow the prompts.
      - **(If installing on CAC, you will need the admin password and must contact support@ionpath.com)**
      - **Git - CAC:** We highly recommend installing git system-wide on the CAC, by downloading the installation utility [here](https://git-scm.com/downloads).
         1. Under Standalone Installer, click the 64-bit Git for Windows Setup link to download the proper installer.
         2. Run the Git setup `.exe` file. It should be version 2.37.1 or higher.
         3. Click `Yes` to allow Git to make the necessary changes.
         4. Click `Next` to accept the GNU License.
         5. Click `Next` to save Git in it's default location. ![alt text](templates/img/git_install/step_01.png "Select Destination Location")
         6. Next, the installer will give you a list of options for each menu. Leave everything to it's default. **We recommend to not change anything, unless you are confident on what you are doing.**
         7. The last menu, will ask if you would like to use any experimental options. Click `Install`, and leave the experimental options unchecked. This will now install Git. ![alt text](templates/img/git_install/step_02.png).
         8.  Open the Windows Terminal, and within the Powershell Tab type `Git` and hit enter. If you see the following output, you're good to go! ![alt text](templates/img/git_install/step_03.png)

  - You will need the latest version of Anaconda (**Miniconda** preferred).
  Download here: https://docs.conda.io/en/latest/miniconda.html and select the appropriate download for your system.
  Choose "Just Me" option for installation, and do not need to select the "Tutorial" or "Getting Started" options.
  Continue with the installation.


  - You will need the latest version of Anaconda (**Miniconda** preferred).
  Download here: https://docs.conda.io/en/latest/miniconda.html and select the appropriate download for your system.
  Choose "Just Me" option for installation, and do not need to select the "Tutorial" or "Getting Started" options.
  Continue with the installation.


  * For Windows, you will need to open the Anaconda powershell prompt instead of the regular powershell prompt for the following.
  <p align="center">
  <img height="400" src="templates/img/conda_powershell.png" width="500"/>
  </p>

  * If you're running `toffy` on macOS, open the terminal.

  If you do not already have git installed, run

  ```shell
  conda install git
  ```
  Navigate to the desired location (ex: Documents) and clone the repo.
  ```
  cd .\Documents\
  git clone https://github.com/angelolab/toffy.git
  ```

  Move into directory and build the environment

  ```shell
  cd toffy
  conda env create -f release-environment.yml
  ```

  This creates a *Python 3.11* environment named `toffy_env`. You can view everything that gets installed by looking at the `release-environment.yml` file.

  If you would like to use the latest version of `toffy`, you can instead run:

  ```shell
  cd toffy
  conda env create -f prerelease-environment.yml
  ```
  Which will create a *Python 3.11* environment named `toffy_prerelease_env`. This will install the latest version of `toffy` from the `main` branch.


  Once you're ready to use the repo, enter the following commands.

  First, activate the environment:

  ```shell
  conda activate toffy_env
  ```

  Once activated, notebooks can be used via this command for Windows:

  ```start_jupyter.sh```

  or this command for macOS:

  ```./start_jupyter.sh```

  You can leave the jupyter notebook running once you're done. If it ever gets closed or you need to reopen it, just follow the steps above.



  The `toffy` repo is constantly being updated. In order to get those changes to your version, you'll need to tell git to update with the following command:

  ```
  git pull
  ```

  After performing the above command, you will sometimes need to update your environment:

  ```shell
  conda remove --name toffy_env --all
  conda env create -f release-environment.yml
  ```

  or

  ```shell
  conda remove --name toffy_prerelease_env --all
  conda env create -f prerelease-environment.yml
  ```

  To update the notebooks, run this command for Windows:

  ```shell
  start_jupyter.sh -u
  ```

  or this command for macOS:

  ```shell
  ./start_jupyter.sh -u
  ```


  Data from each run on the MIBI will be stored in the default base directory `D:\\Data`, in a subdirectory labeled with the run name.
  The [set up](./templates/1_set_up_toffy.ipynb) jupyter notebook creates the following folders that will be used throughout toffy.
  <br> <br>
  Four new folders are created on the D drive:
  - `Extracted_Images`: stores the raw images extracted from the bin files in either the [MIBI monitoring notebook](./templates/3a_monitor_MIBI_run.ipynb) or the [extraction notebook](./templates/3b_extract_images_from_bin.ipynb).
  - `Rosetta_Compensated_Images`: contains the images after being processed with the Rosetta algorithm in the [compensate image data notebook](./templates/4a_compensate_image_data.ipynb)
  - `Normalized_Images`: contains the images after accounting for intensity normalization in the [normalization notebook](./templates/4b_normalize_image_data.ipynb)
  - `Cohorts`: final location of your completely processed image data after renaming the folders and files in the [renaming and reorganizing notebook](./templates/5_rename_and_reorganize.ipynb)

  <figcaption align = "center"><b>Directories in D drive</b></figcaption>

  ![D directories](templates/img/D_dirs.png)

  Within `C:\\Users\\Customer.ION\\Documents` are directories that store necessary files used to set up and monitor a MIBI run.
  - `normalization_curve`: directory which stores the normalization curve file for the machine that was produced by the [set up notebook](./templates/1_set_up_toffy.ipynb) and necessary for [notebook 4b](./templates/4b_normalize_image_data.ipynb)
  - `tiled_image_jsons`: stores all files used to set up a tiled run in the [tiling notebook](./templates/2_create_tiled_mibi_run.ipynb)
  - `autolabeled_tma_jsons`: stores all files used to set up a tma run in the [tma notebook](./templates/2_create_tma_mibi_run.ipynb)
  - `panel_files`: directory containing the run panel file, needed for notebooks 3a, 3b, 4a, and 4b.
  - `watcher_logs`: contains the log file of FOVs which have been processed in the [monitoring notebook](./templates/3a_monitor_MIBI_run.ipynb)
  - `run_metrics`: contains the data files produced by the [QC](./templates/3c_generate_qc_metrics.ipynb) and [MPH notebooks](./templates/3d_compute_median_pulse_height.ipynb)
  - `rosetta_matrices`: directory containing the finalized compensation matrix generated in the [compensation notebook](./templates/4a_compensate_image_data.ipynb)
  - `rosetta_testing`: directory which stores the necessary files for and output of rosetta testing completed in the [compensation notebook](./templates/4a_compensate_image_data.ipynb)

  <figcaption align = "center"><b>Directories in C drive</b></figcaption>

  ![C directories](templates/img/C_dirs.png)

  <br><br>
  You can see below how to pin a folder to Quick Access, which can then be easily located in the section of the same name on the left side of File Explorer.

  We suggest pinning the following folders: `tiled_image_jsons`, `autolabeled_jsons`, `run_metrics`.

  ![Quick Access](templates/img/quick_access.gif)



  Many of the scripts in toffy require a panel file, identifying which targets have been put on which masses. You can download your panel online from the Ionpath MibiTracker under the resources tab. In the panels section, open your panel and click `Download csv`.

  ![panel download](templates/img/panel_download.png)

  You should then copy the file to the `C:\\Users\\Customer.ION\\Documents\panel_files` directory, and rename the file to be descriptive of your run.
  The toffy notebooks expect the panel files to be formatted slightly differently than the Ionpath default. The first time your panel is read in to one of the notebooks, it will be automatically modified by our scripts to contain the necessary information for toffy processing. This includes adding additional channels which are used for compensation, a full list of which can be found in the [example panel file](https://github.com/angelolab/toffy/blob/main/files/example_panel_file.csv).


  The median pulse height (MPH) provides a way to assess the sensitivity of the detector, independent of the specific sample being acquired. It uses characteristics of the output from the detector itself to determine what fraction of maximum sensitivity the instrument is currently running at. We use this fraction of the maximum sensitivity to determine 1) when the detector needs to be swept again and 2) how much to normalize our images by after the fact the correct for this change in sensitivity. The minimum MPH required to still have acceptable signal will depend in part on the markers in your panel, the settings of the instrument, and other factors. However, we often find that the miniumum is somewhere between 5,000 and 6,000 MPH.





  * [Python Poetry](https://python-poetry.org)
    * Recommended to install it with either:
      * [**Official Installer:**](https://python-poetry.org/docs/master/#installing-with-the-official-installer)
          ```sh
          curl -sSL https://install.python-poetry.org | python3 -
          ```
      * [**pipx**](https://python-poetry.org/docs/master/#installing-with-pipx), (requires [`pipx`](https://pypa.github.io/pipx/))
        * If you are using `pipx`, run the following installation commands
          ```sh
          brew install pipx
          pipx ensurepath
          ```
  * [pre-commit](https://pre-commit.com)
      ```sh
      brew install pre-commit
      ```



  1. Clone the repo: `git clone https://github.com/angelolab/toffy.git`
  2. `cd` into `toffy`.
  3. Install the pre-commit hooks with `pre-commit install --install-hooks`
  4. Set up Poetry for `toffy`
     1. Run `poetry install` to install `toffy` into your virtual environment (this will create a local virtual environment).
        1. Poetry utilizes [Python's Virtual Environments](https://docs.python.org/3/tutorial/venv.html))
     2. Run `poetry install --with test`: Installs all the [dependencies needed for tests](pyproject.toml) (labeled under `tool.poetry.group.test.dependencies`)
     3. Run `poetry install --with dev`: Installs all the [dependencies needed for development](pyproject.coml) (labeled under `tool.poetry.group.dev.dependencies`)
     4. You may combine these as well with `poetry install --with dev,test`. Installing the base dependencies and the two optional groups.
  5. In order to test to see if Poetry is working properly, run `poetry show --tree`. This will output the dependency tree for the base dependencies (labeled under `tool.poetry.dependencies`).
  6. All tests can be run with `poetry run pytest`
  7. For every commit, *pre-commit* will format your changes to be complient with `pycodestyle`.



  If you have a general question or are having trouble with part of the repo, head to the [discussions](https://github.com/angelolab/toffy/discussions) tab to get help. If you've found a bug with the codebase, first make sure there's not already an [open issue](https://github.com/angelolab/toffy/issues), and if not, you can then [open an issue](https://github.com/angelolab/toffy/issues/new/choose) describing the bug.

  Before opening, please double check and see that someone else hasn't opened an issue for your question already.


  Please directly cite the `toffy` repo (https://github.com/angelolab/toffy) if it was a part of your analysis.


pkgId: bbc3ea54fb0ca061a0c36d023a64a8a11709e3ec0e786656e489b5fba70b1d7f
name: python-Tooldelta-help
arch: noarch
version: 0.11.0
epoch: 0
release: 1
summary: Development documents and examples for Tooldelta
url: https://github.com/ToolDelta-Basic/ToolDelta
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Tooldelta-0.11.0-1.src.rpm
location_href: Packages/python-Tooldelta-help-0.11.0-1.noarch.rpm
checksum_type: sha256
description:
  <h1 align="center">ToolDelta - Multi Platform Edition</h1>
  <p align="center">
    <a href="https://github.com/ToolDelta/ToolDelta/releases"><img src="https://img.shields.io/github/v/release/ToolDelta/ToolDelta?display_name=tag&sort=semver" alt="Releases"></a>
    <img src="https://img.shields.io/github/stars/ToolDelta/ToolDelta.svg?style=falt" alt="Stars">
  </p>

  <p align="center">
    <a href="https://github.com/ToolDelta/ToolDelta/issues"><img src="https://img.shields.io/github/issues/ToolDelta/ToolDelta.svg?style=flat" alt="opissues"></a>
    <a href="https://github.com/ToolDelta/ToolDelta/issues?q=is%3Aissue+is%3Aclosed"><img src="https://img.shields.io/github/issues-closed/ToolDelta/ToolDelta.svg?style=flat&color=success" alt="clissues"></a>
    <a href="https://github.com/ToolDelta/ToolDelta/pulls"><img src="https://img.shields.io/github/issues-pr/ToolDelta/ToolDelta.svg?style=falt" alt="oppr"></a>
    <a href="https://github.com/ToolDelta/ToolDelta/pulls?q=is%3Apr+is%3Aclosed"><img src="https://img.shields.io/github/issues-pr-closed/ToolDelta/ToolDelta.svg?style=flat&color=success" alt="clpr"></a>
    <a><img src="https://sonarcloud.io/api/project_badges/measure?project=ToolDelta_ToolDelta&metric=alert_status" alt="clpr"></a>
  </p>

  <p align="center">
    <b>ToolDelta</b> 是依赖于 <b>PhoenixBuilder | Neo Omega</b> 的多功能扩展组件，可以加载各种各样有趣的插件。
    <br/><b>ToolDelta</b> 可以使得你的 <b>中国版《我的世界》基岩版租赁服</b> 的玩法和功能更加多样化。
    <br/><a href="https://tooldelta-wiki.tblstudio.cn/">维基和用户指南</a> | <a href="http://qm.qq.com/cgi-bin/qm/qr?_wv=1027&k=ywf-Y9Sb7G3McLAN7TveI-qh-g1FEtLB&authKey=C0ZLK09UWRzWv9dpReVnZljSnZ15crGpNpdT5O%2BX%2B%2BQvZ%2Bsm2BWfN8qqdJ5OMnTq&noverify=0&group_code=194838530">交流群</a>
  </p>



  - [目录](#目录)
  - [插件市场](#插件市场)
  - [注意事项](#注意事项)
  - [友情链接](#友情链接)
  - [运行和配置](#运行和配置)




  - ToolDelta 的插件市场在 [这里](https://github.com/ToolDelta-Basic/PluginMarket)




  - 遇到平台不兼容的情况请尽快提交 `Issue`
  - 已支持 `Termux`




  - [如何使用](https://td-wiki.dqyt.online)
  - [Docker 镜像](https://hub.docker.com/r/wlingzhenyu/tooldelta)




   - 直接下载 ToolDelta 可执行文件并运行
      - <a href="https://github.com/ToolDelta/ToolDelta/releases">发行版 ToolDelta 下载点这里</a>
   - 在 `pip` 安装 ToolDelta 并运行
      - `pip install tooldelta`
      - `echo import tooldelta;tooldelta.client_title() > main.py`
      运行:
        - `python main.py` 或 `python3 main.py`
   - 在docker运行
      ```bash
      docker run -v .:/app -t -i registry.cn-hangzhou.aliyuncs.com/dqyt/tooldelta:latest
      ```


pkgId: 2b5e1fedeac4892c3cd7472f5c5812a607bf81492538ac6fbf4e1e0df74af42a
name: python-TweetCatcherPy-help
arch: noarch
version: 0.0.2
epoch: 0
release: 1
summary: Development documents and examples for TweetCatcherPy
url: https://github.com/lnstchtped/TweetCatcherPy
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-TweetCatcherPy-0.0.2-1.src.rpm
location_href: Packages/python-TweetCatcherPy-help-0.0.2-1.noarch.rpm
checksum_type: sha256
description:
  To install TweetCatcherPy, simply add it to your project dependencies using `pip`:
  ```bash
  pip install TweetCatcherPy


pkgId: a8d4138778f0b0c73641e9204f07e437e401c5488090f26b6edc0433ff4234a4
name: python-URAdime-help
arch: noarch
version: 0.1.9
epoch: 0
release: 1
summary: Development documents and examples for URAdime
url: https://github.com/SemiQuant/URAdime
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-URAdime-0.1.9-1.src.rpm
location_href: Packages/python-URAdime-help-0.1.9-1.noarch.rpm
checksum_type: sha256
description:
  URAdime (Universal Read Analysis of DIMErs) is a Python package for analyzing primer sequences in sequencing data to identify dimers and chimeras.



  ```bash
  pip install uradime
  ```



  URAdime can be used both as a command-line tool and as a Python package.



  ```bash

  uradime -b input.bam -p primers.tsv -o results/my_analysis


  uradime \
      -b input.bam \                    # Input BAM file
      -p primers.tsv \                  # Primer file (tab-separated)
      -o results/my_analysis \          # Output prefix
      -t 8 \                            # Number of threads
      -m 1000 \                         # Maximum reads to process (0 for all)
      -c 100 \                          # Chunk size for parallel processing
      -u \                              # Process only unaligned reads
      --max-distance 2 \                # Maximum Levenshtein distance for matching
      --unaligned-only \                # only check the unaligned reads
      --window-size 20 \                # Allowed padding on the 5' ends of the reads, sometime needs to be very big due to universal tails etc. setting this parameter too large can cause unexpected results
      --ignore-amplicon-size \          # Usefull if short read sequecing like Illumina where the paired read length is not the size of the actual amplicon
      --check-termini \                 # Turn off check for partial matches at read termini
      --terminus-length 14 \            # Length of terminus to check for partial matches
      --overlap-threshold 0.8 \         # Minimum fraction of overlap required to consider primers as overlapping (0.0-1.0), this is added for hissPCR support
      --downsample 5.0 \                # Percentage of reads to randomly sample from the BAM file (0.1-100.0)
      -v                                # Verbose output
  ```





  ```python
  from uradime import bam_to_fasta_parallel, create_analysis_summary, load_primers


  result_df = bam_to_fasta_parallel(
      bam_path="your_file.bam",
      primer_file="primers.tsv",
      num_threads=4
  )


  primers_df, _ = load_primers("primers.tsv")


  summary_df, matched_pairs, mismatched_pairs = create_analysis_summary(result_df, primers_df)
  ```




  The primer file should be tab-separated with the following columns:
  - Name: Primer pair name
  - Forward: Forward primer sequence
  - Reverse: Reverse primer sequence
  - Size: Expected amplicon size

  Example:
  ```
  Name    Forward             Reverse             Size
  Pair1   ATCGATCGATCG       TAGCTAGCTAGC       100
  Pair2   GCTAGCTAGCTA       CGATTCGATCGA       150
  ```



  The tool generates several CSV files with the analysis results:
  - `*_summary.csv`: Overall analysis summary
  - `*_matched_pairs.csv`: Reads with matching primer pairs
  - `*_mismatched_pairs.csv`: Reads with mismatched primer pairs
  - `*_wrong_size_pairs.csv`: Reads with correct primer pairs but wrong size




  - Python ≥3.7
  - pysam
  - pandas
  - biopython
  - python-Levenshtein
  - tqdm
  - numpy



  This project is licensed under GNU GPL.


pkgId: d56e48f8f4f4473a2a47fd0d634e1f4e6fc18ec928bca4531154fc56824047ca
name: python-UTN-FRA-help
arch: noarch
version: 1.0.0.0
epoch: 0
release: 1
summary: Development documents and examples for UTN-FRA
url: https://pypi.org/project/UTN-FRA/
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-UTN-FRA-1.0.0.0-1.src.rpm
location_href: Packages/python-UTN-FRA-help-1.0.0.0-1.noarch.rpm
checksum_type: sha256
description:
  <table>
      <tr>
          <td align='center'>
              <img alt="Logo UTN Large" src="https://github.com/caidevOficial/Logos/blob/master/Personales/Logo_Developer.png?raw=true" href="https://www.utnfravirtual.org.ar/" width="750px"/>
          </td>
      </tr>
  </table></br>






  Te proveemos un gran set de datos de Pok&eacute;mones, en forma de lista de diccionarios para que puedas realizar tus ejercicios.

  Para poder usarlos importa en tus modulos lo siguiente

  ```py
  from UTN_FRA.datasets import (
      lista_pokemones, clear_console
  )
  ```

  A partir de este punto, estas en condiciones de utilizar la lista, imprimirla, recorrerla o hacer lo que se te plazca


  Esta funcion puede usarse como auxiliar.

  ```py

  clear_console()
  ```


pkgId: 8d102ffbf59a5096b5823731a89b7cddc9c47c1a1f7a9df5e2b3584dde1bf366
name: python-Unified-python-sdk-help
arch: noarch
version: 0.27.0
epoch: 0
release: 1
summary: Development documents and examples for Unified-python-sdk
url: https://github.com/unified-to/unified-python-sdk.git
rpm_license: None
rpm_group: Unspecified
rpm_buildhost: localhost
rpm_sourcerpm: python-Unified-python-sdk-0.27.0-1.src.rpm
location_href: Packages/python-Unified-python-sdk-help-0.27.0-1.noarch.rpm
checksum_type: sha256
description:
  <div align="left">
      <a href="https://speakeasyapi.dev/"><img src="https://custom-icon-badges.demolab.com/badge/-Built%20By%20Speakeasy-212015?style=for-the-badge&logoColor=FBE331&logo=speakeasy&labelColor=545454" /></a>
      <a href="https://github.com/unified-to/unified-python-sdk/actions"><img src="https://img.shields.io/github/actions/workflow/status/unified-to/unified-python-sdk/speakeasy_sdk_generation.yml?style=for-the-badge" /></a>

  </div>

  <!-- Start Summary [summary] -->


  Unified.to API: One API to Rule Them All
  <!-- End Summary [summary] -->

  <!-- Start Table of Contents [toc] -->

  <!-- $toc-max-depth=2 -->
    * [SDK Installation](https://github.com/unified-to/unified-python-sdk/blob/master/#sdk-installation)
    * [IDE Support](https://github.com/unified-to/unified-python-sdk/blob/master/#ide-support)
    * [SDK Example Usage](https://github.com/unified-to/unified-python-sdk/blob/master/#sdk-example-usage)
    * [Available Resources and Operations](https://github.com/unified-to/unified-python-sdk/blob/master/#available-resources-and-operations)
    * [File uploads](https://github.com/unified-to/unified-python-sdk/blob/master/#file-uploads)
    * [Retries](https://github.com/unified-to/unified-python-sdk/blob/master/#retries)
    * [Error Handling](https://github.com/unified-to/unified-python-sdk/blob/master/#error-handling)
    * [Server Selection](https://github.com/unified-to/unified-python-sdk/blob/master/#server-selection)
    * [Custom HTTP Client](https://github.com/unified-to/unified-python-sdk/blob/master/#custom-http-client)
    * [Authentication](https://github.com/unified-to/unified-python-sdk/blob/master/#authentication)
    * [Debugging](https://github.com/unified-to/unified-python-sdk/blob/master/#debugging)

  <!-- End Table of Contents [toc] -->

  <!-- Start SDK Installation [installation] -->


  The SDK can be installed with either *pip* or *poetry* package managers.



  *PIP* is the default package installer for Python, enabling easy installation and management of packages from PyPI via the command line.

  ```bash
  pip install Unified-python-sdk
  ```



  *Poetry* is a modern tool that simplifies dependency management and package publishing by using a single `pyproject.toml` file to handle project metadata and dependencies.

  ```bash
  poetry add Unified-python-sdk
  ```
  <!-- End SDK Installation [installation] -->

  <!-- Start IDE Support [idesupport] -->




  Generally, the SDK will work well with most IDEs out of the box. However, when using PyCharm, you can enjoy much better integration with Pydantic by installing an additional plugin.

  - [PyCharm Pydantic Plugin](https://docs.pydantic.dev/latest/integrations/pycharm/)
  <!-- End IDE Support [idesupport] -->

  <!-- Start SDK Example Usage [usage] -->




  ```python

  from unified_python_sdk import UnifiedTo
  from unified_python_sdk.models import shared

  with UnifiedTo(
      security=shared.Security(
          jwt="<YOUR_API_KEY_HERE>",
      ),
  ) as unified_to:

      res = unified_to.accounting.create_accounting_account(request={
          "connection_id": "<value>",
      })

      assert res.accounting_account is not None

      
      print(res.accounting_account)
  ```

  </br>

  The same SDK client can also be used to make asychronous requests by importing asyncio.
  ```python

  import asyncio
  from unified_python_sdk import UnifiedTo
  from unified_python_sdk.models import shared

  async def main():
      async with UnifiedTo(
          security=shared.Security(
              jwt="<YOUR_API_KEY_HERE>",
          ),
      ) as unified_to:

          res = await unified_to.accounting.create_accounting_account_async(request={
              "connection_id": "<value>",
          })

          assert res.accounting_account is not None

          
          print(res.accounting_account)

  asyncio.run(main())
  ```
  <!-- End SDK Example Usage [usage] -->

  <!-- Start Available Resources and Operations [operations] -->


  <details open>
  <summary>Available methods</summary>



  * [create_accounting_account](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/account/README.md#create_accounting_account) - Create an account
  * [get_accounting_account](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/account/README.md#get_accounting_account) - Retrieve an account
  * [list_accounting_accounts](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/account/README.md#list_accounting_accounts) - List all accounts
  * [patch_accounting_account](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/account/README.md#patch_accounting_account) - Update an account
  * [remove_accounting_account](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/account/README.md#remove_accounting_account) - Remove an account
  * [update_accounting_account](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/account/README.md#update_accounting_account) - Update an account



  * [create_accounting_account](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#create_accounting_account) - Create an account
  * [create_accounting_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#create_accounting_contact) - Create a contact
  * [create_accounting_invoice](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#create_accounting_invoice) - Create an invoice
  * [create_accounting_journal](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#create_accounting_journal) - Create a journal
  * [create_accounting_order](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#create_accounting_order) - Create an order
  * [create_accounting_taxrate](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#create_accounting_taxrate) - Create a taxrate
  * [create_accounting_transaction](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#create_accounting_transaction) - Create a transaction
  * [get_accounting_account](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#get_accounting_account) - Retrieve an account
  * [get_accounting_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#get_accounting_contact) - Retrieve a contact
  * [get_accounting_invoice](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#get_accounting_invoice) - Retrieve an invoice
  * [get_accounting_journal](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#get_accounting_journal) - Retrieve a journal
  * [get_accounting_order](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#get_accounting_order) - Retrieve an order
  * [get_accounting_organization](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#get_accounting_organization) - Retrieve an organization
  * [get_accounting_taxrate](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#get_accounting_taxrate) - Retrieve a taxrate
  * [get_accounting_transaction](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#get_accounting_transaction) - Retrieve a transaction
  * [list_accounting_accounts](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#list_accounting_accounts) - List all accounts
  * [list_accounting_contacts](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#list_accounting_contacts) - List all contacts
  * [list_accounting_invoices](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#list_accounting_invoices) - List all invoices
  * [list_accounting_journals](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#list_accounting_journals) - List all journals
  * [list_accounting_orders](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#list_accounting_orders) - List all orders
  * [list_accounting_organizations](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#list_accounting_organizations) - List all organizations
  * [list_accounting_taxrates](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#list_accounting_taxrates) - List all taxrates
  * [list_accounting_transactions](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#list_accounting_transactions) - List all transactions
  * [patch_accounting_account](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#patch_accounting_account) - Update an account
  * [patch_accounting_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#patch_accounting_contact) - Update a contact
  * [patch_accounting_invoice](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#patch_accounting_invoice) - Update an invoice
  * [patch_accounting_journal](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#patch_accounting_journal) - Update a journal
  * [patch_accounting_order](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#patch_accounting_order) - Update an order
  * [patch_accounting_taxrate](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#patch_accounting_taxrate) - Update a taxrate
  * [patch_accounting_transaction](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#patch_accounting_transaction) - Update a transaction
  * [remove_accounting_account](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#remove_accounting_account) - Remove an account
  * [remove_accounting_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#remove_accounting_contact) - Remove a contact
  * [remove_accounting_invoice](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#remove_accounting_invoice) - Remove an invoice
  * [remove_accounting_journal](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#remove_accounting_journal) - Remove a journal
  * [remove_accounting_order](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#remove_accounting_order) - Remove an order
  * [remove_accounting_taxrate](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#remove_accounting_taxrate) - Remove a taxrate
  * [remove_accounting_transaction](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#remove_accounting_transaction) - Remove a transaction
  * [update_accounting_account](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#update_accounting_account) - Update an account
  * [update_accounting_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#update_accounting_contact) - Update a contact
  * [update_accounting_invoice](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#update_accounting_invoice) - Update an invoice
  * [update_accounting_journal](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#update_accounting_journal) - Update a journal
  * [update_accounting_order](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#update_accounting_order) - Update an order
  * [update_accounting_taxrate](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#update_accounting_taxrate) - Update a taxrate
  * [update_accounting_transaction](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/accounting/README.md#update_accounting_transaction) - Update a transaction



  * [create_ats_activity](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/activity/README.md#create_ats_activity) - Create an activity
  * [get_ats_activity](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/activity/README.md#get_ats_activity) - Retrieve an activity
  * [list_ats_activities](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/activity/README.md#list_ats_activities) - List all activities
  * [patch_ats_activity](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/activity/README.md#patch_ats_activity) - Update an activity
  * [remove_ats_activity](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/activity/README.md#remove_ats_activity) - Remove an activity
  * [update_ats_activity](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/activity/README.md#update_ats_activity) - Update an activity



  * [get_unified_apicall](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/apicall/README.md#get_unified_apicall) - Retrieve specific API Call by its ID
  * [list_unified_apicalls](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/apicall/README.md#list_unified_apicalls) - Returns API Calls



  * [create_ats_application](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/application/README.md#create_ats_application) - Create an application
  * [get_ats_application](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/application/README.md#get_ats_application) - Retrieve an application
  * [list_ats_applications](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/application/README.md#list_ats_applications) - List all applications
  * [patch_ats_application](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/application/README.md#patch_ats_application) - Update an application
  * [remove_ats_application](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/application/README.md#remove_ats_application) - Remove an application
  * [update_ats_application](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/application/README.md#update_ats_application) - Update an application



  * [list_ats_applicationstatuses](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/applicationstatus/README.md#list_ats_applicationstatuses) - List all applicationstatuses



  * [create_ats_activity](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#create_ats_activity) - Create an activity
  * [create_ats_application](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#create_ats_application) - Create an application
  * [create_ats_candidate](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#create_ats_candidate) - Create a candidate
  * [create_ats_document](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#create_ats_document) - Create a document
  * [create_ats_interview](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#create_ats_interview) - Create an interview
  * [create_ats_job](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#create_ats_job) - Create a job
  * [create_ats_scorecard](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#create_ats_scorecard) - Create a scorecard
  * [get_ats_activity](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#get_ats_activity) - Retrieve an activity
  * [get_ats_application](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#get_ats_application) - Retrieve an application
  * [get_ats_candidate](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#get_ats_candidate) - Retrieve a candidate
  * [get_ats_company](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#get_ats_company) - Retrieve a company
  * [get_ats_document](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#get_ats_document) - Retrieve a document
  * [get_ats_interview](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#get_ats_interview) - Retrieve an interview
  * [get_ats_job](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#get_ats_job) - Retrieve a job
  * [get_ats_scorecard](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#get_ats_scorecard) - Retrieve a scorecard
  * [list_ats_activities](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#list_ats_activities) - List all activities
  * [list_ats_applications](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#list_ats_applications) - List all applications
  * [list_ats_applicationstatuses](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#list_ats_applicationstatuses) - List all applicationstatuses
  * [list_ats_candidates](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#list_ats_candidates) - List all candidates
  * [list_ats_companies](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#list_ats_companies) - List all companies
  * [list_ats_documents](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#list_ats_documents) - List all documents
  * [list_ats_interviews](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#list_ats_interviews) - List all interviews
  * [list_ats_jobs](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#list_ats_jobs) - List all jobs
  * [list_ats_scorecards](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#list_ats_scorecards) - List all scorecards
  * [patch_ats_activity](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#patch_ats_activity) - Update an activity
  * [patch_ats_application](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#patch_ats_application) - Update an application
  * [patch_ats_candidate](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#patch_ats_candidate) - Update a candidate
  * [patch_ats_document](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#patch_ats_document) - Update a document
  * [patch_ats_interview](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#patch_ats_interview) - Update an interview
  * [patch_ats_job](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#patch_ats_job) - Update a job
  * [patch_ats_scorecard](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#patch_ats_scorecard) - Update a scorecard
  * [remove_ats_activity](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#remove_ats_activity) - Remove an activity
  * [remove_ats_application](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#remove_ats_application) - Remove an application
  * [remove_ats_candidate](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#remove_ats_candidate) - Remove a candidate
  * [remove_ats_document](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#remove_ats_document) - Remove a document
  * [remove_ats_interview](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#remove_ats_interview) - Remove an interview
  * [remove_ats_job](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#remove_ats_job) - Remove a job
  * [remove_ats_scorecard](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#remove_ats_scorecard) - Remove a scorecard
  * [update_ats_activity](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#update_ats_activity) - Update an activity
  * [update_ats_application](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#update_ats_application) - Update an application
  * [update_ats_candidate](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#update_ats_candidate) - Update a candidate
  * [update_ats_document](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#update_ats_document) - Update a document
  * [update_ats_interview](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#update_ats_interview) - Update an interview
  * [update_ats_job](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#update_ats_job) - Update a job
  * [update_ats_scorecard](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ats/README.md#update_ats_scorecard) - Update a scorecard



  * [get_unified_integration_auth](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/auth/README.md#get_unified_integration_auth) - Create connection indirectly
  * [get_unified_integration_login](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/auth/README.md#get_unified_integration_login) - Sign in a user



  * [create_repo_branch](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/branch/README.md#create_repo_branch) - Create a branch
  * [get_repo_branch](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/branch/README.md#get_repo_branch) - Retrieve a branch
  * [list_repo_branches](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/branch/README.md#list_repo_branches) - List all branches
  * [patch_repo_branch](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/branch/README.md#patch_repo_branch) - Update a branch
  * [remove_repo_branch](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/branch/README.md#remove_repo_branch) - Remove a branch
  * [update_repo_branch](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/branch/README.md#update_repo_branch) - Update a branch



  * [list_uc_calls](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/call/README.md#list_uc_calls) - List all calls



  * [create_ats_candidate](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/candidate/README.md#create_ats_candidate) - Create a candidate
  * [get_ats_candidate](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/candidate/README.md#get_ats_candidate) - Retrieve a candidate
  * [list_ats_candidates](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/candidate/README.md#list_ats_candidates) - List all candidates
  * [patch_ats_candidate](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/candidate/README.md#patch_ats_candidate) - Update a candidate
  * [remove_ats_candidate](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/candidate/README.md#remove_ats_candidate) - Remove a candidate
  * [update_ats_candidate](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/candidate/README.md#update_ats_candidate) - Update a candidate



  * [get_messaging_channel](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/channel/README.md#get_messaging_channel) - Retrieve a channel
  * [list_messaging_channels](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/channel/README.md#list_messaging_channels) - List all channels



  * [create_lms_class](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/class/README.md#create_lms_class) - Create a class
  * [get_lms_class](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/class/README.md#get_lms_class) - Retrieve a class
  * [list_lms_classes](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/class/README.md#list_lms_classes) - List all classes
  * [patch_lms_class](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/class/README.md#patch_lms_class) - Update a class
  * [remove_lms_class](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/class/README.md#remove_lms_class) - Remove a class
  * [update_lms_class](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/class/README.md#update_lms_class) - Update a class



  * [create_commerce_collection](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/collection/README.md#create_commerce_collection) - Create a collection
  * [get_commerce_collection](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/collection/README.md#get_commerce_collection) - Retrieve a collection
  * [list_commerce_collections](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/collection/README.md#list_commerce_collections) - List all collections
  * [patch_commerce_collection](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/collection/README.md#patch_commerce_collection) - Update a collection
  * [remove_commerce_collection](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/collection/README.md#remove_commerce_collection) - Remove a collection
  * [update_commerce_collection](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/collection/README.md#update_commerce_collection) - Update a collection



  * [create_commerce_collection](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#create_commerce_collection) - Create a collection
  * [create_commerce_inventory](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#create_commerce_inventory) - Create an inventory
  * [create_commerce_item](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#create_commerce_item) - Create an item
  * [create_commerce_location](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#create_commerce_location) - Create a location
  * [get_commerce_collection](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#get_commerce_collection) - Retrieve a collection
  * [get_commerce_inventory](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#get_commerce_inventory) - Retrieve an inventory
  * [get_commerce_item](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#get_commerce_item) - Retrieve an item
  * [get_commerce_location](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#get_commerce_location) - Retrieve a location
  * [list_commerce_collections](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#list_commerce_collections) - List all collections
  * [list_commerce_inventories](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#list_commerce_inventories) - List all inventories
  * [list_commerce_items](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#list_commerce_items) - List all items
  * [list_commerce_locations](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#list_commerce_locations) - List all locations
  * [patch_commerce_collection](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#patch_commerce_collection) - Update a collection
  * [patch_commerce_inventory](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#patch_commerce_inventory) - Update an inventory
  * [patch_commerce_item](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#patch_commerce_item) - Update an item
  * [patch_commerce_location](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#patch_commerce_location) - Update a location
  * [remove_commerce_collection](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#remove_commerce_collection) - Remove a collection
  * [remove_commerce_inventory](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#remove_commerce_inventory) - Remove an inventory
  * [remove_commerce_item](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#remove_commerce_item) - Remove an item
  * [remove_commerce_location](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#remove_commerce_location) - Remove a location
  * [update_commerce_collection](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#update_commerce_collection) - Update a collection
  * [update_commerce_inventory](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#update_commerce_inventory) - Update an inventory
  * [update_commerce_item](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#update_commerce_item) - Update an item
  * [update_commerce_location](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commerce/README.md#update_commerce_location) - Update a location



  * [create_repo_commit](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commit/README.md#create_repo_commit) - Create a commit
  * [get_repo_commit](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commit/README.md#get_repo_commit) - Retrieve a commit
  * [list_repo_commits](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commit/README.md#list_repo_commits) - List all commits
  * [patch_repo_commit](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commit/README.md#patch_repo_commit) - Update a commit
  * [remove_repo_commit](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commit/README.md#remove_repo_commit) - Remove a commit
  * [update_repo_commit](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/commit/README.md#update_repo_commit) - Update a commit



  * [create_crm_company](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/company/README.md#create_crm_company) - Create a company
  * [create_hris_company](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/company/README.md#create_hris_company) - Create a company
  * [get_ats_company](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/company/README.md#get_ats_company) - Retrieve a company
  * [get_crm_company](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/company/README.md#get_crm_company) - Retrieve a company
  * [get_hris_company](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/company/README.md#get_hris_company) - Retrieve a company
  * [list_ats_companies](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/company/README.md#list_ats_companies) - List all companies
  * [list_crm_companies](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/company/README.md#list_crm_companies) - List all companies
  * [list_enrich_companies](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/company/README.md#list_enrich_companies) - Retrieve enrichment information for a company
  * [list_hris_companies](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/company/README.md#list_hris_companies) - List all companies
  * [patch_crm_company](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/company/README.md#patch_crm_company) - Update a company
  * [patch_hris_company](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/company/README.md#patch_hris_company) - Update a company
  * [remove_crm_company](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/company/README.md#remove_crm_company) - Remove a company
  * [remove_hris_company](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/company/README.md#remove_hris_company) - Remove a company
  * [update_crm_company](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/company/README.md#update_crm_company) - Update a company
  * [update_hris_company](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/company/README.md#update_hris_company) - Update a company



  * [create_unified_connection](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/connection/README.md#create_unified_connection) - Create connection
  * [get_unified_connection](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/connection/README.md#get_unified_connection) - Retrieve connection
  * [list_unified_connections](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/connection/README.md#list_unified_connections) - List all connections
  * [patch_unified_connection](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/connection/README.md#patch_unified_connection) - Update connection
  * [remove_unified_connection](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/connection/README.md#remove_unified_connection) - Remove connection
  * [update_unified_connection](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/connection/README.md#update_unified_connection) - Update connection



  * [create_accounting_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/contact/README.md#create_accounting_contact) - Create a contact
  * [create_crm_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/contact/README.md#create_crm_contact) - Create a contact
  * [create_uc_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/contact/README.md#create_uc_contact) - Create a contact
  * [get_accounting_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/contact/README.md#get_accounting_contact) - Retrieve a contact
  * [get_crm_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/contact/README.md#get_crm_contact) - Retrieve a contact
  * [get_uc_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/contact/README.md#get_uc_contact) - Retrieve a contact
  * [list_accounting_contacts](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/contact/README.md#list_accounting_contacts) - List all contacts
  * [list_crm_contacts](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/contact/README.md#list_crm_contacts) - List all contacts
  * [list_uc_contacts](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/contact/README.md#list_uc_contacts) - List all contacts
  * [patch_accounting_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/contact/README.md#patch_accounting_contact) - Update a contact
  * [patch_crm_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/contact/README.md#patch_crm_contact) - Update a contact
  * [patch_uc_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/contact/README.md#patch_uc_contact) - Update a contact
  * [remove_accounting_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/contact/README.md#remove_accounting_contact) - Remove a contact
  * [remove_crm_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/contact/README.md#remove_crm_contact) - Remove a contact
  * [remove_uc_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/contact/README.md#remove_uc_contact) - Remove a contact
  * [update_accounting_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/contact/README.md#update_accounting_contact) - Update a contact
  * [update_crm_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/contact/README.md#update_crm_contact) - Update a contact
  * [update_uc_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/contact/README.md#update_uc_contact) - Update a contact



  * [create_lms_course](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/course/README.md#create_lms_course) - Create a course
  * [get_lms_course](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/course/README.md#get_lms_course) - Retrieve a course
  * [list_lms_courses](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/course/README.md#list_lms_courses) - List all courses
  * [patch_lms_course](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/course/README.md#patch_lms_course) - Update a course
  * [remove_lms_course](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/course/README.md#remove_lms_course) - Remove a course
  * [update_lms_course](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/course/README.md#update_lms_course) - Update a course



  * [create_crm_company](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#create_crm_company) - Create a company
  * [create_crm_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#create_crm_contact) - Create a contact
  * [create_crm_deal](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#create_crm_deal) - Create a deal
  * [create_crm_event](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#create_crm_event) - Create an event
  * [create_crm_lead](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#create_crm_lead) - Create a lead
  * [create_crm_pipeline](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#create_crm_pipeline) - Create a pipeline
  * [get_crm_company](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#get_crm_company) - Retrieve a company
  * [get_crm_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#get_crm_contact) - Retrieve a contact
  * [get_crm_deal](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#get_crm_deal) - Retrieve a deal
  * [get_crm_event](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#get_crm_event) - Retrieve an event
  * [get_crm_lead](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#get_crm_lead) - Retrieve a lead
  * [get_crm_pipeline](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#get_crm_pipeline) - Retrieve a pipeline
  * [list_crm_companies](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#list_crm_companies) - List all companies
  * [list_crm_contacts](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#list_crm_contacts) - List all contacts
  * [list_crm_deals](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#list_crm_deals) - List all deals
  * [list_crm_events](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#list_crm_events) - List all events
  * [list_crm_leads](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#list_crm_leads) - List all leads
  * [list_crm_pipelines](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#list_crm_pipelines) - List all pipelines
  * [patch_crm_company](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#patch_crm_company) - Update a company
  * [patch_crm_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#patch_crm_contact) - Update a contact
  * [patch_crm_deal](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#patch_crm_deal) - Update a deal
  * [patch_crm_event](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#patch_crm_event) - Update an event
  * [patch_crm_lead](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#patch_crm_lead) - Update a lead
  * [patch_crm_pipeline](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#patch_crm_pipeline) - Update a pipeline
  * [remove_crm_company](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#remove_crm_company) - Remove a company
  * [remove_crm_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#remove_crm_contact) - Remove a contact
  * [remove_crm_deal](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#remove_crm_deal) - Remove a deal
  * [remove_crm_event](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#remove_crm_event) - Remove an event
  * [remove_crm_lead](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#remove_crm_lead) - Remove a lead
  * [remove_crm_pipeline](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#remove_crm_pipeline) - Remove a pipeline
  * [update_crm_company](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#update_crm_company) - Update a company
  * [update_crm_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#update_crm_contact) - Update a contact
  * [update_crm_deal](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#update_crm_deal) - Update a deal
  * [update_crm_event](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#update_crm_event) - Update an event
  * [update_crm_lead](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#update_crm_lead) - Update a lead
  * [update_crm_pipeline](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/crm/README.md#update_crm_pipeline) - Update a pipeline



  * [create_ticketing_customer](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/customer/README.md#create_ticketing_customer) - Create a customer
  * [get_ticketing_customer](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/customer/README.md#get_ticketing_customer) - Retrieve a customer
  * [list_ticketing_customers](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/customer/README.md#list_ticketing_customers) - List all customers
  * [patch_ticketing_customer](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/customer/README.md#patch_ticketing_customer) - Update a customer
  * [remove_ticketing_customer](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/customer/README.md#remove_ticketing_customer) - Remove a customer
  * [update_ticketing_customer](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/customer/README.md#update_ticketing_customer) - Update a customer



  * [create_crm_deal](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/deal/README.md#create_crm_deal) - Create a deal
  * [get_crm_deal](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/deal/README.md#get_crm_deal) - Retrieve a deal
  * [list_crm_deals](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/deal/README.md#list_crm_deals) - List all deals
  * [patch_crm_deal](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/deal/README.md#patch_crm_deal) - Update a deal
  * [remove_crm_deal](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/deal/README.md#remove_crm_deal) - Remove a deal
  * [update_crm_deal](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/deal/README.md#update_crm_deal) - Update a deal



  * [create_ats_document](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/document/README.md#create_ats_document) - Create a document
  * [get_ats_document](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/document/README.md#get_ats_document) - Retrieve a document
  * [list_ats_documents](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/document/README.md#list_ats_documents) - List all documents
  * [patch_ats_document](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/document/README.md#patch_ats_document) - Update a document
  * [remove_ats_document](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/document/README.md#remove_ats_document) - Remove a document
  * [update_ats_document](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/document/README.md#update_ats_document) - Update a document



  * [create_hris_employee](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/employee/README.md#create_hris_employee) - Create an employee
  * [get_hris_employee](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/employee/README.md#get_hris_employee) - Retrieve an employee
  * [list_hris_employees](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/employee/README.md#list_hris_employees) - List all employees
  * [patch_hris_employee](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/employee/README.md#patch_hris_employee) - Update an employee
  * [remove_hris_employee](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/employee/README.md#remove_hris_employee) - Remove an employee
  * [update_hris_employee](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/employee/README.md#update_hris_employee) - Update an employee



  * [list_enrich_companies](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/enrich/README.md#list_enrich_companies) - Retrieve enrichment information for a company
  * [list_enrich_people](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/enrich/README.md#list_enrich_people) - Retrieve enrichment information for a person



  * [create_crm_event](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/event/README.md#create_crm_event) - Create an event
  * [get_crm_event](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/event/README.md#get_crm_event) - Retrieve an event
  * [list_crm_events](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/event/README.md#list_crm_events) - List all events
  * [patch_crm_event](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/event/README.md#patch_crm_event) - Update an event
  * [remove_crm_event](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/event/README.md#remove_crm_event) - Remove an event
  * [update_crm_event](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/event/README.md#update_crm_event) - Update an event



  * [create_storage_file](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/file/README.md#create_storage_file) - Create a file
  * [get_storage_file](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/file/README.md#get_storage_file) - Retrieve a file
  * [list_storage_files](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/file/README.md#list_storage_files) - List all files
  * [patch_storage_file](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/file/README.md#patch_storage_file) - Update a file
  * [remove_storage_file](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/file/README.md#remove_storage_file) - Remove a file
  * [update_storage_file](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/file/README.md#update_storage_file) - Update a file



  * [create_genai_prompt](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/genai/README.md#create_genai_prompt) - Create a prompt
  * [list_genai_models](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/genai/README.md#list_genai_models) - List all models



  * [create_hris_group](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/group/README.md#create_hris_group) - Create a group
  * [create_scim_groups](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/group/README.md#create_scim_groups) - Create group
  * [get_hris_group](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/group/README.md#get_hris_group) - Retrieve a group
  * [get_scim_groups](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/group/README.md#get_scim_groups) - Get group
  * [list_hris_groups](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/group/README.md#list_hris_groups) - List all groups
  * [list_scim_groups](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/group/README.md#list_scim_groups) - List groups
  * [patch_hris_group](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/group/README.md#patch_hris_group) - Update a group
  * [patch_scim_groups](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/group/README.md#patch_scim_groups) - Update group
  * [remove_hris_group](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/group/README.md#remove_hris_group) - Remove a group
  * [remove_scim_groups](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/group/README.md#remove_scim_groups) - Delete group
  * [update_hris_group](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/group/README.md#update_hris_group) - Update a group
  * [update_scim_groups](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/group/README.md#update_scim_groups) - Update group



  * [create_hris_company](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#create_hris_company) - Create a company
  * [create_hris_employee](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#create_hris_employee) - Create an employee
  * [create_hris_group](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#create_hris_group) - Create a group
  * [create_hris_location](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#create_hris_location) - Create a location
  * [get_hris_company](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#get_hris_company) - Retrieve a company
  * [get_hris_employee](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#get_hris_employee) - Retrieve an employee
  * [get_hris_group](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#get_hris_group) - Retrieve a group
  * [get_hris_location](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#get_hris_location) - Retrieve a location
  * [get_hris_payslip](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#get_hris_payslip) - Retrieve a payslip
  * [get_hris_timeoff](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#get_hris_timeoff) - Retrieve a timeoff
  * [list_hris_companies](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#list_hris_companies) - List all companies
  * [list_hris_employees](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#list_hris_employees) - List all employees
  * [list_hris_groups](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#list_hris_groups) - List all groups
  * [list_hris_locations](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#list_hris_locations) - List all locations
  * [list_hris_payslips](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#list_hris_payslips) - List all payslips
  * [list_hris_timeoffs](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#list_hris_timeoffs) - List all timeoffs
  * [patch_hris_company](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#patch_hris_company) - Update a company
  * [patch_hris_employee](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#patch_hris_employee) - Update an employee
  * [patch_hris_group](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#patch_hris_group) - Update a group
  * [patch_hris_location](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#patch_hris_location) - Update a location
  * [remove_hris_company](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#remove_hris_company) - Remove a company
  * [remove_hris_employee](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#remove_hris_employee) - Remove an employee
  * [remove_hris_group](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#remove_hris_group) - Remove a group
  * [remove_hris_location](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#remove_hris_location) - Remove a location
  * [update_hris_company](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#update_hris_company) - Update a company
  * [update_hris_employee](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#update_hris_employee) - Update an employee
  * [update_hris_group](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#update_hris_group) - Update a group
  * [update_hris_location](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/hris/README.md#update_hris_location) - Update a location



  * [create_lms_instructor](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/instructor/README.md#create_lms_instructor) - Create an instructor
  * [get_lms_instructor](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/instructor/README.md#get_lms_instructor) - Retrieve an instructor
  * [list_lms_instructors](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/instructor/README.md#list_lms_instructors) - List all instructors
  * [patch_lms_instructor](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/instructor/README.md#patch_lms_instructor) - Update an instructor
  * [remove_lms_instructor](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/instructor/README.md#remove_lms_instructor) - Remove an instructor
  * [update_lms_instructor](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/instructor/README.md#update_lms_instructor) - Update an instructor



  * [get_unified_integration_auth](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/integration/README.md#get_unified_integration_auth) - Create connection indirectly
  * [list_unified_integration_workspaces](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/integration/README.md#list_unified_integration_workspaces) - Returns all activated integrations in a workspace
  * [list_unified_integrations](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/integration/README.md#list_unified_integrations) - Returns all integrations



  * [create_ats_interview](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/interview/README.md#create_ats_interview) - Create an interview
  * [get_ats_interview](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/interview/README.md#get_ats_interview) - Retrieve an interview
  * [list_ats_interviews](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/interview/README.md#list_ats_interviews) - List all interviews
  * [patch_ats_interview](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/interview/README.md#patch_ats_interview) - Update an interview
  * [remove_ats_interview](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/interview/README.md#remove_ats_interview) - Remove an interview
  * [update_ats_interview](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/interview/README.md#update_ats_interview) - Update an interview



  * [create_commerce_inventory](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/inventory/README.md#create_commerce_inventory) - Create an inventory
  * [get_commerce_inventory](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/inventory/README.md#get_commerce_inventory) - Retrieve an inventory
  * [list_commerce_inventories](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/inventory/README.md#list_commerce_inventories) - List all inventories
  * [patch_commerce_inventory](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/inventory/README.md#patch_commerce_inventory) - Update an inventory
  * [remove_commerce_inventory](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/inventory/README.md#remove_commerce_inventory) - Remove an inventory
  * [update_commerce_inventory](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/inventory/README.md#update_commerce_inventory) - Update an inventory



  * [create_accounting_invoice](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/invoice/README.md#create_accounting_invoice) - Create an invoice
  * [get_accounting_invoice](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/invoice/README.md#get_accounting_invoice) - Retrieve an invoice
  * [list_accounting_invoices](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/invoice/README.md#list_accounting_invoices) - List all invoices
  * [patch_accounting_invoice](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/invoice/README.md#patch_accounting_invoice) - Update an invoice
  * [remove_accounting_invoice](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/invoice/README.md#remove_accounting_invoice) - Remove an invoice
  * [update_accounting_invoice](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/invoice/README.md#update_accounting_invoice) - Update an invoice



  * [list_unified_issues](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/issue/README.md#list_unified_issues) - List support issues



  * [create_commerce_item](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/item/README.md#create_commerce_item) - Create an item
  * [get_commerce_item](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/item/README.md#get_commerce_item) - Retrieve an item
  * [list_commerce_items](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/item/README.md#list_commerce_items) - List all items
  * [patch_commerce_item](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/item/README.md#patch_commerce_item) - Update an item
  * [remove_commerce_item](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/item/README.md#remove_commerce_item) - Remove an item
  * [update_commerce_item](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/item/README.md#update_commerce_item) - Update an item



  * [create_ats_job](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/job/README.md#create_ats_job) - Create a job
  * [get_ats_job](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/job/README.md#get_ats_job) - Retrieve a job
  * [list_ats_jobs](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/job/README.md#list_ats_jobs) - List all jobs
  * [patch_ats_job](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/job/README.md#patch_ats_job) - Update a job
  * [remove_ats_job](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/job/README.md#remove_ats_job) - Remove a job
  * [update_ats_job](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/job/README.md#update_ats_job) - Update a job



  * [create_accounting_journal](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/journal/README.md#create_accounting_journal) - Create a journal
  * [get_accounting_journal](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/journal/README.md#get_accounting_journal) - Retrieve a journal
  * [list_accounting_journals](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/journal/README.md#list_accounting_journals) - List all journals
  * [patch_accounting_journal](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/journal/README.md#patch_accounting_journal) - Update a journal
  * [remove_accounting_journal](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/journal/README.md#remove_accounting_journal) - Remove a journal
  * [update_accounting_journal](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/journal/README.md#update_accounting_journal) - Update a journal



  * [create_kms_page](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/kms/README.md#create_kms_page) - Create a page
  * [create_kms_space](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/kms/README.md#create_kms_space) - Create a space
  * [get_kms_page](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/kms/README.md#get_kms_page) - Retrieve a page
  * [get_kms_space](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/kms/README.md#get_kms_space) - Retrieve a space
  * [list_kms_pages](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/kms/README.md#list_kms_pages) - List all pages
  * [list_kms_spaces](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/kms/README.md#list_kms_spaces) - List all spaces
  * [patch_kms_page](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/kms/README.md#patch_kms_page) - Update a page
  * [patch_kms_space](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/kms/README.md#patch_kms_space) - Update a space
  * [remove_kms_page](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/kms/README.md#remove_kms_page) - Remove a page
  * [remove_kms_space](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/kms/README.md#remove_kms_space) - Remove a space
  * [update_kms_page](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/kms/README.md#update_kms_page) - Update a page
  * [update_kms_space](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/kms/README.md#update_kms_space) - Update a space



  * [create_crm_lead](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lead/README.md#create_crm_lead) - Create a lead
  * [get_crm_lead](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lead/README.md#get_crm_lead) - Retrieve a lead
  * [list_crm_leads](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lead/README.md#list_crm_leads) - List all leads
  * [patch_crm_lead](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lead/README.md#patch_crm_lead) - Update a lead
  * [remove_crm_lead](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lead/README.md#remove_crm_lead) - Remove a lead
  * [update_crm_lead](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lead/README.md#update_crm_lead) - Update a lead



  * [create_payment_link](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/link/README.md#create_payment_link) - Create a link
  * [get_payment_link](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/link/README.md#get_payment_link) - Retrieve a link
  * [list_payment_links](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/link/README.md#list_payment_links) - List all links
  * [patch_payment_link](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/link/README.md#patch_payment_link) - Update a link
  * [remove_payment_link](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/link/README.md#remove_payment_link) - Remove a link
  * [update_payment_link](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/link/README.md#update_payment_link) - Update a link



  * [create_martech_list](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/list/README.md#create_martech_list) - Create a list
  * [get_martech_list](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/list/README.md#get_martech_list) - Retrieve a list
  * [list_martech_lists](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/list/README.md#list_martech_lists) - List all lists
  * [patch_martech_list](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/list/README.md#patch_martech_list) - Update a list
  * [remove_martech_list](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/list/README.md#remove_martech_list) - Remove a list
  * [update_martech_list](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/list/README.md#update_martech_list) - Update a list



  * [create_lms_class](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#create_lms_class) - Create a class
  * [create_lms_course](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#create_lms_course) - Create a course
  * [create_lms_instructor](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#create_lms_instructor) - Create an instructor
  * [create_lms_student](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#create_lms_student) - Create a student
  * [get_lms_class](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#get_lms_class) - Retrieve a class
  * [get_lms_course](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#get_lms_course) - Retrieve a course
  * [get_lms_instructor](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#get_lms_instructor) - Retrieve an instructor
  * [get_lms_student](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#get_lms_student) - Retrieve a student
  * [list_lms_classes](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#list_lms_classes) - List all classes
  * [list_lms_courses](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#list_lms_courses) - List all courses
  * [list_lms_instructors](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#list_lms_instructors) - List all instructors
  * [list_lms_students](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#list_lms_students) - List all students
  * [patch_lms_class](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#patch_lms_class) - Update a class
  * [patch_lms_course](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#patch_lms_course) - Update a course
  * [patch_lms_instructor](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#patch_lms_instructor) - Update an instructor
  * [patch_lms_student](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#patch_lms_student) - Update a student
  * [remove_lms_class](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#remove_lms_class) - Remove a class
  * [remove_lms_course](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#remove_lms_course) - Remove a course
  * [remove_lms_instructor](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#remove_lms_instructor) - Remove an instructor
  * [remove_lms_student](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#remove_lms_student) - Remove a student
  * [update_lms_class](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#update_lms_class) - Update a class
  * [update_lms_course](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#update_lms_course) - Update a course
  * [update_lms_instructor](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#update_lms_instructor) - Update an instructor
  * [update_lms_student](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/lms/README.md#update_lms_student) - Update a student



  * [create_commerce_location](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/location/README.md#create_commerce_location) - Create a location
  * [create_hris_location](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/location/README.md#create_hris_location) - Create a location
  * [get_commerce_location](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/location/README.md#get_commerce_location) - Retrieve a location
  * [get_hris_location](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/location/README.md#get_hris_location) - Retrieve a location
  * [list_commerce_locations](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/location/README.md#list_commerce_locations) - List all locations
  * [list_hris_locations](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/location/README.md#list_hris_locations) - List all locations
  * [patch_commerce_location](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/location/README.md#patch_commerce_location) - Update a location
  * [patch_hris_location](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/location/README.md#patch_hris_location) - Update a location
  * [remove_commerce_location](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/location/README.md#remove_commerce_location) - Remove a location
  * [remove_hris_location](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/location/README.md#remove_hris_location) - Remove a location
  * [update_commerce_location](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/location/README.md#update_commerce_location) - Update a location
  * [update_hris_location](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/location/README.md#update_hris_location) - Update a location



  * [get_unified_integration_login](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/login/README.md#get_unified_integration_login) - Sign in a user



  * [create_martech_list](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/martech/README.md#create_martech_list) - Create a list
  * [create_martech_member](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/martech/README.md#create_martech_member) - Create a member
  * [get_martech_list](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/martech/README.md#get_martech_list) - Retrieve a list
  * [get_martech_member](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/martech/README.md#get_martech_member) - Retrieve a member
  * [list_martech_lists](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/martech/README.md#list_martech_lists) - List all lists
  * [list_martech_members](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/martech/README.md#list_martech_members) - List all members
  * [patch_martech_list](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/martech/README.md#patch_martech_list) - Update a list
  * [patch_martech_member](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/martech/README.md#patch_martech_member) - Update a member
  * [remove_martech_list](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/martech/README.md#remove_martech_list) - Remove a list
  * [remove_martech_member](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/martech/README.md#remove_martech_member) - Remove a member
  * [update_martech_list](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/martech/README.md#update_martech_list) - Update a list
  * [update_martech_member](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/martech/README.md#update_martech_member) - Update a member



  * [create_martech_member](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/member/README.md#create_martech_member) - Create a member
  * [get_martech_member](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/member/README.md#get_martech_member) - Retrieve a member
  * [list_martech_members](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/member/README.md#list_martech_members) - List all members
  * [patch_martech_member](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/member/README.md#patch_martech_member) - Update a member
  * [remove_martech_member](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/member/README.md#remove_martech_member) - Remove a member
  * [update_martech_member](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/member/README.md#update_martech_member) - Update a member



  * [create_messaging_message](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/message/README.md#create_messaging_message) - Create a message
  * [get_messaging_message](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/message/README.md#get_messaging_message) - Retrieve a message
  * [list_messaging_messages](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/message/README.md#list_messaging_messages) - List all messages
  * [patch_messaging_message](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/message/README.md#patch_messaging_message) - Update a message
  * [remove_messaging_message](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/message/README.md#remove_messaging_message) - Remove a message
  * [update_messaging_message](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/message/README.md#update_messaging_message) - Update a message



  * [create_messaging_message](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/messaging/README.md#create_messaging_message) - Create a message
  * [get_messaging_channel](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/messaging/README.md#get_messaging_channel) - Retrieve a channel
  * [get_messaging_message](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/messaging/README.md#get_messaging_message) - Retrieve a message
  * [list_messaging_channels](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/messaging/README.md#list_messaging_channels) - List all channels
  * [list_messaging_messages](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/messaging/README.md#list_messaging_messages) - List all messages
  * [patch_messaging_message](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/messaging/README.md#patch_messaging_message) - Update a message
  * [remove_messaging_message](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/messaging/README.md#remove_messaging_message) - Remove a message
  * [update_messaging_message](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/messaging/README.md#update_messaging_message) - Update a message



  * [create_metadata_metadata](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/metadata/README.md#create_metadata_metadata) - Create a metadata
  * [get_metadata_metadata](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/metadata/README.md#get_metadata_metadata) - Retrieve a metadata
  * [list_metadata_metadatas](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/metadata/README.md#list_metadata_metadatas) - List all metadatas
  * [patch_metadata_metadata](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/metadata/README.md#patch_metadata_metadata) - Update a metadata
  * [remove_metadata_metadata](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/metadata/README.md#remove_metadata_metadata) - Remove a metadata
  * [update_metadata_metadata](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/metadata/README.md#update_metadata_metadata) - Update a metadata



  * [list_genai_models](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/model/README.md#list_genai_models) - List all models



  * [create_ticketing_note](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/note/README.md#create_ticketing_note) - Create a note
  * [get_ticketing_note](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/note/README.md#get_ticketing_note) - Retrieve a note
  * [list_ticketing_notes](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/note/README.md#list_ticketing_notes) - List all notes
  * [patch_ticketing_note](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/note/README.md#patch_ticketing_note) - Update a note
  * [remove_ticketing_note](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/note/README.md#remove_ticketing_note) - Remove a note
  * [update_ticketing_note](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/note/README.md#update_ticketing_note) - Update a note



  * [create_accounting_order](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/order/README.md#create_accounting_order) - Create an order
  * [get_accounting_order](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/order/README.md#get_accounting_order) - Retrieve an order
  * [list_accounting_orders](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/order/README.md#list_accounting_orders) - List all orders
  * [patch_accounting_order](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/order/README.md#patch_accounting_order) - Update an order
  * [remove_accounting_order](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/order/README.md#remove_accounting_order) - Remove an order
  * [update_accounting_order](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/order/README.md#update_accounting_order) - Update an order



  * [create_repo_organization](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/organization/README.md#create_repo_organization) - Create an organization
  * [get_accounting_organization](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/organization/README.md#get_accounting_organization) - Retrieve an organization
  * [get_repo_organization](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/organization/README.md#get_repo_organization) - Retrieve an organization
  * [list_accounting_organizations](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/organization/README.md#list_accounting_organizations) - List all organizations
  * [list_repo_organizations](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/organization/README.md#list_repo_organizations) - List all organizations
  * [patch_repo_organization](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/organization/README.md#patch_repo_organization) - Update an organization
  * [remove_repo_organization](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/organization/README.md#remove_repo_organization) - Remove an organization
  * [update_repo_organization](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/organization/README.md#update_repo_organization) - Update an organization



  * [create_kms_page](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/page/README.md#create_kms_page) - Create a page
  * [get_kms_page](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/page/README.md#get_kms_page) - Retrieve a page
  * [list_kms_pages](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/page/README.md#list_kms_pages) - List all pages
  * [patch_kms_page](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/page/README.md#patch_kms_page) - Update a page
  * [remove_kms_page](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/page/README.md#remove_kms_page) - Remove a page
  * [update_kms_page](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/page/README.md#update_kms_page) - Update a page



  * [create_passthrough_json](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/passthrough/README.md#create_passthrough_json) - Passthrough POST
  * [create_passthrough_raw](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/passthrough/README.md#create_passthrough_raw) - Passthrough POST
  * [list_passthroughs](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/passthrough/README.md#list_passthroughs) - Passthrough GET
  * [patch_passthrough_json](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/passthrough/README.md#patch_passthrough_json) - Passthrough PUT
  * [patch_passthrough_raw](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/passthrough/README.md#patch_passthrough_raw) - Passthrough PUT
  * [remove_passthrough](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/passthrough/README.md#remove_passthrough) - Passthrough DELETE
  * [update_passthrough_json](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/passthrough/README.md#update_passthrough_json) - Passthrough PUT
  * [update_passthrough_raw](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/passthrough/README.md#update_passthrough_raw) - Passthrough PUT



  * [create_payment_link](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/payment/README.md#create_payment_link) - Create a link
  * [create_payment_payment](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/payment/README.md#create_payment_payment) - Create a payment
  * [get_payment_link](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/payment/README.md#get_payment_link) - Retrieve a link
  * [get_payment_payment](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/payment/README.md#get_payment_payment) - Retrieve a payment
  * [get_payment_payout](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/payment/README.md#get_payment_payout) - Retrieve a payout
  * [get_payment_refund](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/payment/README.md#get_payment_refund) - Retrieve a refund
  * [list_payment_links](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/payment/README.md#list_payment_links) - List all links
  * [list_payment_payments](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/payment/README.md#list_payment_payments) - List all payments
  * [list_payment_payouts](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/payment/README.md#list_payment_payouts) - List all payouts
  * [list_payment_refunds](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/payment/README.md#list_payment_refunds) - List all refunds
  * [patch_payment_link](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/payment/README.md#patch_payment_link) - Update a link
  * [patch_payment_payment](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/payment/README.md#patch_payment_payment) - Update a payment
  * [remove_payment_link](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/payment/README.md#remove_payment_link) - Remove a link
  * [remove_payment_payment](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/payment/README.md#remove_payment_payment) - Remove a payment
  * [update_payment_link](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/payment/README.md#update_payment_link) - Update a link
  * [update_payment_payment](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/payment/README.md#update_payment_payment) - Update a payment



  * [get_payment_payout](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/payout/README.md#get_payment_payout) - Retrieve a payout
  * [list_payment_payouts](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/payout/README.md#list_payment_payouts) - List all payouts



  * [get_hris_payslip](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/payslip/README.md#get_hris_payslip) - Retrieve a payslip
  * [list_hris_payslips](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/payslip/README.md#list_hris_payslips) - List all payslips



  * [list_enrich_people](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/person/README.md#list_enrich_people) - Retrieve enrichment information for a person



  * [create_crm_pipeline](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/pipeline/README.md#create_crm_pipeline) - Create a pipeline
  * [get_crm_pipeline](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/pipeline/README.md#get_crm_pipeline) - Retrieve a pipeline
  * [list_crm_pipelines](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/pipeline/README.md#list_crm_pipelines) - List all pipelines
  * [patch_crm_pipeline](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/pipeline/README.md#patch_crm_pipeline) - Update a pipeline
  * [remove_crm_pipeline](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/pipeline/README.md#remove_crm_pipeline) - Remove a pipeline
  * [update_crm_pipeline](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/pipeline/README.md#update_crm_pipeline) - Update a pipeline



  * [create_task_project](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/project/README.md#create_task_project) - Create a project
  * [get_task_project](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/project/README.md#get_task_project) - Retrieve a project
  * [list_task_projects](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/project/README.md#list_task_projects) - List all projects
  * [patch_task_project](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/project/README.md#patch_task_project) - Update a project
  * [remove_task_project](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/project/README.md#remove_task_project) - Remove a project
  * [update_task_project](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/project/README.md#update_task_project) - Update a project



  * [create_genai_prompt](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/prompt/README.md#create_genai_prompt) - Create a prompt



  * [create_repo_pullrequest](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/pullrequest/README.md#create_repo_pullrequest) - Create a pullrequest
  * [get_repo_pullrequest](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/pullrequest/README.md#get_repo_pullrequest) - Retrieve a pullrequest
  * [list_repo_pullrequests](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/pullrequest/README.md#list_repo_pullrequests) - List all pullrequests
  * [patch_repo_pullrequest](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/pullrequest/README.md#patch_repo_pullrequest) - Update a pullrequest
  * [remove_repo_pullrequest](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/pullrequest/README.md#remove_repo_pullrequest) - Remove a pullrequest
  * [update_repo_pullrequest](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/pullrequest/README.md#update_repo_pullrequest) - Update a pullrequest



  * [get_payment_refund](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/refund/README.md#get_payment_refund) - Retrieve a refund
  * [list_payment_refunds](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/refund/README.md#list_payment_refunds) - List all refunds



  * [create_repo_branch](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#create_repo_branch) - Create a branch
  * [create_repo_commit](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#create_repo_commit) - Create a commit
  * [create_repo_organization](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#create_repo_organization) - Create an organization
  * [create_repo_pullrequest](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#create_repo_pullrequest) - Create a pullrequest
  * [create_repo_repository](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#create_repo_repository) - Create a repository
  * [get_repo_branch](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#get_repo_branch) - Retrieve a branch
  * [get_repo_commit](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#get_repo_commit) - Retrieve a commit
  * [get_repo_organization](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#get_repo_organization) - Retrieve an organization
  * [get_repo_pullrequest](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#get_repo_pullrequest) - Retrieve a pullrequest
  * [get_repo_repository](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#get_repo_repository) - Retrieve a repository
  * [list_repo_branches](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#list_repo_branches) - List all branches
  * [list_repo_commits](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#list_repo_commits) - List all commits
  * [list_repo_organizations](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#list_repo_organizations) - List all organizations
  * [list_repo_pullrequests](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#list_repo_pullrequests) - List all pullrequests
  * [list_repo_repositories](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#list_repo_repositories) - List all repositories
  * [patch_repo_branch](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#patch_repo_branch) - Update a branch
  * [patch_repo_commit](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#patch_repo_commit) - Update a commit
  * [patch_repo_organization](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#patch_repo_organization) - Update an organization
  * [patch_repo_pullrequest](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#patch_repo_pullrequest) - Update a pullrequest
  * [patch_repo_repository](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#patch_repo_repository) - Update a repository
  * [remove_repo_branch](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#remove_repo_branch) - Remove a branch
  * [remove_repo_commit](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#remove_repo_commit) - Remove a commit
  * [remove_repo_organization](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#remove_repo_organization) - Remove an organization
  * [remove_repo_pullrequest](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#remove_repo_pullrequest) - Remove a pullrequest
  * [remove_repo_repository](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#remove_repo_repository) - Remove a repository
  * [update_repo_branch](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#update_repo_branch) - Update a branch
  * [update_repo_commit](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#update_repo_commit) - Update a commit
  * [update_repo_organization](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#update_repo_organization) - Update an organization
  * [update_repo_pullrequest](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#update_repo_pullrequest) - Update a pullrequest
  * [update_repo_repository](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repo/README.md#update_repo_repository) - Update a repository



  * [create_repo_repository](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repository/README.md#create_repo_repository) - Create a repository
  * [get_repo_repository](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repository/README.md#get_repo_repository) - Retrieve a repository
  * [list_repo_repositories](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repository/README.md#list_repo_repositories) - List all repositories
  * [patch_repo_repository](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repository/README.md#patch_repo_repository) - Update a repository
  * [remove_repo_repository](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repository/README.md#remove_repo_repository) - Remove a repository
  * [update_repo_repository](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/repository/README.md#update_repo_repository) - Update a repository



  * [create_scim_groups](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/scim/README.md#create_scim_groups) - Create group
  * [create_scim_users](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/scim/README.md#create_scim_users) - Create user
  * [get_scim_groups](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/scim/README.md#get_scim_groups) - Get group
  * [get_scim_users](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/scim/README.md#get_scim_users) - Get user
  * [list_scim_groups](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/scim/README.md#list_scim_groups) - List groups
  * [list_scim_users](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/scim/README.md#list_scim_users) - List users
  * [patch_scim_groups](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/scim/README.md#patch_scim_groups) - Update group
  * [patch_scim_users](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/scim/README.md#patch_scim_users) - Update user
  * [remove_scim_groups](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/scim/README.md#remove_scim_groups) - Delete group
  * [remove_scim_users](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/scim/README.md#remove_scim_users) - Delete user
  * [update_scim_groups](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/scim/README.md#update_scim_groups) - Update group
  * [update_scim_users](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/scim/README.md#update_scim_users) - Update user



  * [create_ats_scorecard](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/scorecard/README.md#create_ats_scorecard) - Create a scorecard
  * [get_ats_scorecard](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/scorecard/README.md#get_ats_scorecard) - Retrieve a scorecard
  * [list_ats_scorecards](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/scorecard/README.md#list_ats_scorecards) - List all scorecards
  * [patch_ats_scorecard](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/scorecard/README.md#patch_ats_scorecard) - Update a scorecard
  * [remove_ats_scorecard](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/scorecard/README.md#remove_ats_scorecard) - Remove a scorecard
  * [update_ats_scorecard](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/scorecard/README.md#update_ats_scorecard) - Update a scorecard



  * [create_kms_space](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/space/README.md#create_kms_space) - Create a space
  * [get_kms_space](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/space/README.md#get_kms_space) - Retrieve a space
  * [list_kms_spaces](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/space/README.md#list_kms_spaces) - List all spaces
  * [patch_kms_space](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/space/README.md#patch_kms_space) - Update a space
  * [remove_kms_space](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/space/README.md#remove_kms_space) - Remove a space
  * [update_kms_space](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/space/README.md#update_kms_space) - Update a space



  * [create_storage_file](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/storage/README.md#create_storage_file) - Create a file
  * [get_storage_file](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/storage/README.md#get_storage_file) - Retrieve a file
  * [list_storage_files](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/storage/README.md#list_storage_files) - List all files
  * [patch_storage_file](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/storage/README.md#patch_storage_file) - Update a file
  * [remove_storage_file](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/storage/README.md#remove_storage_file) - Remove a file
  * [update_storage_file](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/storage/README.md#update_storage_file) - Update a file



  * [create_lms_student](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/student/README.md#create_lms_student) - Create a student
  * [get_lms_student](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/student/README.md#get_lms_student) - Retrieve a student
  * [list_lms_students](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/student/README.md#list_lms_students) - List all students
  * [patch_lms_student](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/student/README.md#patch_lms_student) - Update a student
  * [remove_lms_student](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/student/README.md#remove_lms_student) - Remove a student
  * [update_lms_student](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/student/README.md#update_lms_student) - Update a student



  * [create_task_project](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/task/README.md#create_task_project) - Create a project
  * [create_task_task](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/task/README.md#create_task_task) - Create a task
  * [get_task_project](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/task/README.md#get_task_project) - Retrieve a project
  * [get_task_task](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/task/README.md#get_task_task) - Retrieve a task
  * [list_task_projects](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/task/README.md#list_task_projects) - List all projects
  * [list_task_tasks](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/task/README.md#list_task_tasks) - List all tasks
  * [patch_task_project](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/task/README.md#patch_task_project) - Update a project
  * [patch_task_task](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/task/README.md#patch_task_task) - Update a task
  * [remove_task_project](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/task/README.md#remove_task_project) - Remove a project
  * [remove_task_task](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/task/README.md#remove_task_task) - Remove a task
  * [update_task_project](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/task/README.md#update_task_project) - Update a project
  * [update_task_task](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/task/README.md#update_task_task) - Update a task



  * [create_accounting_taxrate](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/taxrate/README.md#create_accounting_taxrate) - Create a taxrate
  * [get_accounting_taxrate](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/taxrate/README.md#get_accounting_taxrate) - Retrieve a taxrate
  * [list_accounting_taxrates](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/taxrate/README.md#list_accounting_taxrates) - List all taxrates
  * [patch_accounting_taxrate](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/taxrate/README.md#patch_accounting_taxrate) - Update a taxrate
  * [remove_accounting_taxrate](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/taxrate/README.md#remove_accounting_taxrate) - Remove a taxrate
  * [update_accounting_taxrate](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/taxrate/README.md#update_accounting_taxrate) - Update a taxrate



  * [create_ticketing_ticket](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticket/README.md#create_ticketing_ticket) - Create a ticket
  * [get_ticketing_ticket](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticket/README.md#get_ticketing_ticket) - Retrieve a ticket
  * [list_ticketing_tickets](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticket/README.md#list_ticketing_tickets) - List all tickets
  * [patch_ticketing_ticket](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticket/README.md#patch_ticketing_ticket) - Update a ticket
  * [remove_ticketing_ticket](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticket/README.md#remove_ticketing_ticket) - Remove a ticket
  * [update_ticketing_ticket](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticket/README.md#update_ticketing_ticket) - Update a ticket



  * [create_ticketing_customer](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticketing/README.md#create_ticketing_customer) - Create a customer
  * [create_ticketing_note](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticketing/README.md#create_ticketing_note) - Create a note
  * [create_ticketing_ticket](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticketing/README.md#create_ticketing_ticket) - Create a ticket
  * [get_ticketing_customer](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticketing/README.md#get_ticketing_customer) - Retrieve a customer
  * [get_ticketing_note](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticketing/README.md#get_ticketing_note) - Retrieve a note
  * [get_ticketing_ticket](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticketing/README.md#get_ticketing_ticket) - Retrieve a ticket
  * [list_ticketing_customers](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticketing/README.md#list_ticketing_customers) - List all customers
  * [list_ticketing_notes](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticketing/README.md#list_ticketing_notes) - List all notes
  * [list_ticketing_tickets](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticketing/README.md#list_ticketing_tickets) - List all tickets
  * [patch_ticketing_customer](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticketing/README.md#patch_ticketing_customer) - Update a customer
  * [patch_ticketing_note](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticketing/README.md#patch_ticketing_note) - Update a note
  * [patch_ticketing_ticket](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticketing/README.md#patch_ticketing_ticket) - Update a ticket
  * [remove_ticketing_customer](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticketing/README.md#remove_ticketing_customer) - Remove a customer
  * [remove_ticketing_note](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticketing/README.md#remove_ticketing_note) - Remove a note
  * [remove_ticketing_ticket](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticketing/README.md#remove_ticketing_ticket) - Remove a ticket
  * [update_ticketing_customer](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticketing/README.md#update_ticketing_customer) - Update a customer
  * [update_ticketing_note](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticketing/README.md#update_ticketing_note) - Update a note
  * [update_ticketing_ticket](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/ticketing/README.md#update_ticketing_ticket) - Update a ticket



  * [get_hris_timeoff](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/timeoff/README.md#get_hris_timeoff) - Retrieve a timeoff
  * [list_hris_timeoffs](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/timeoff/README.md#list_hris_timeoffs) - List all timeoffs



  * [create_accounting_transaction](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/transaction/README.md#create_accounting_transaction) - Create a transaction
  * [get_accounting_transaction](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/transaction/README.md#get_accounting_transaction) - Retrieve a transaction
  * [list_accounting_transactions](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/transaction/README.md#list_accounting_transactions) - List all transactions
  * [patch_accounting_transaction](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/transaction/README.md#patch_accounting_transaction) - Update a transaction
  * [remove_accounting_transaction](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/transaction/README.md#remove_accounting_transaction) - Remove a transaction
  * [update_accounting_transaction](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/transaction/README.md#update_accounting_transaction) - Update a transaction



  * [create_uc_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/uc/README.md#create_uc_contact) - Create a contact
  * [get_uc_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/uc/README.md#get_uc_contact) - Retrieve a contact
  * [list_uc_calls](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/uc/README.md#list_uc_calls) - List all calls
  * [list_uc_contacts](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/uc/README.md#list_uc_contacts) - List all contacts
  * [patch_uc_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/uc/README.md#patch_uc_contact) - Update a contact
  * [remove_uc_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/uc/README.md#remove_uc_contact) - Remove a contact
  * [update_uc_contact](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/uc/README.md#update_uc_contact) - Update a contact



  * [create_unified_connection](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/unified/README.md#create_unified_connection) - Create connection
  * [create_unified_webhook](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/unified/README.md#create_unified_webhook) - Create webhook subscription
  * [get_unified_apicall](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/unified/README.md#get_unified_apicall) - Retrieve specific API Call by its ID
  * [get_unified_connection](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/unified/README.md#get_unified_connection) - Retrieve connection
  * [get_unified_integration_auth](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/unified/README.md#get_unified_integration_auth) - Create connection indirectly
  * [get_unified_webhook](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/unified/README.md#get_unified_webhook) - Retrieve webhook by its ID
  * [list_unified_apicalls](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/unified/README.md#list_unified_apicalls) - Returns API Calls
  * [list_unified_connections](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/unified/README.md#list_unified_connections) - List all connections
  * [list_unified_integration_workspaces](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/unified/README.md#list_unified_integration_workspaces) - Returns all activated integrations in a workspace
  * [list_unified_integrations](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/unified/README.md#list_unified_integrations) - Returns all integrations
  * [list_unified_issues](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/unified/README.md#list_unified_issues) - List support issues
  * [list_unified_webhooks](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/unified/README.md#list_unified_webhooks) - Returns all registered webhooks
  * [patch_unified_connection](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/unified/README.md#patch_unified_connection) - Update connection
  * [patch_unified_webhook](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/unified/README.md#patch_unified_webhook) - Update webhook subscription
  * [patch_unified_webhook_trigger](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/unified/README.md#patch_unified_webhook_trigger) - Trigger webhook
  * [remove_unified_connection](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/unified/README.md#remove_unified_connection) - Remove connection
  * [remove_unified_webhook](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/unified/README.md#remove_unified_webhook) - Remove webhook subscription
  * [update_unified_connection](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/unified/README.md#update_unified_connection) - Update connection
  * [update_unified_webhook](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/unified/README.md#update_unified_webhook) - Update webhook subscription
  * [update_unified_webhook_trigger](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/unified/README.md#update_unified_webhook_trigger) - Trigger webhook




  * [create_scim_users](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/user/README.md#create_scim_users) - Create user
  * [get_scim_users](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/user/README.md#get_scim_users) - Get user
  * [list_scim_users](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/user/README.md#list_scim_users) - List users
  * [patch_scim_users](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/user/README.md#patch_scim_users) - Update user
  * [remove_scim_users](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/user/README.md#remove_scim_users) - Delete user
  * [update_scim_users](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/user/README.md#update_scim_users) - Update user



  * [create_unified_webhook](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/webhook/README.md#create_unified_webhook) - Create webhook subscription
  * [get_unified_webhook](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/webhook/README.md#get_unified_webhook) - Retrieve webhook by its ID
  * [list_unified_webhooks](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/webhook/README.md#list_unified_webhooks) - Returns all registered webhooks
  * [patch_unified_webhook](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/webhook/README.md#patch_unified_webhook) - Update webhook subscription
  * [patch_unified_webhook_trigger](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/webhook/README.md#patch_unified_webhook_trigger) - Trigger webhook
  * [remove_unified_webhook](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/webhook/README.md#remove_unified_webhook) - Remove webhook subscription
  * [update_unified_webhook](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/webhook/README.md#update_unified_webhook) - Update webhook subscription
  * [update_unified_webhook_trigger](https://github.com/unified-to/unified-python-sdk/blob/master/docs/sdks/webhook/README.md#update_unified_webhook_trigger) - Trigger webhook

  </details>
  <!-- End Available Resources and Operations [operations] -->







  <!-- Start File uploads [file-upload] -->


  Certain SDK methods accept file objects as part of a request body or multi-part request. It is possible and typically recommended to upload files as a stream rather than reading the entire contents into memory. This avoids excessive memory consumption and potentially crashing with out-of-memory errors when working with very large files. The following example demonstrates how to attach a file stream to a request.

  > [!TIP]
  >
  > For endpoints that handle file uploads bytes arrays can also be used. However, using streams is recommended for large files.
  >

  ```python
  from unified_python_sdk import UnifiedTo
  from unified_python_sdk.models import shared

  with UnifiedTo(
      security=shared.Security(
          jwt="<YOUR_API_KEY_HERE>",
      ),
  ) as unified_to:

      res = unified_to.passthrough.create_passthrough_raw(request={
          "connection_id": "<value>",
          "path": "/etc/periodic",
      })

      assert res is not None

      
      print(res)

  ```
  <!-- End File uploads [file-upload] -->

  <!-- Start Retries [retries] -->


  Some of the endpoints in this SDK support retries. If you use the SDK without any configuration, it will fall back to the default retry strategy provided by the API. However, the default retry strategy can be overridden on a per-operation basis, or across the entire SDK.

  To change the default retry strategy for a single API call, simply provide a `RetryConfig` object to the call:
  ```python
  from unified_python_sdk import UnifiedTo
  from unified_python_sdk.models import shared
  from unified_python_sdk.utils import BackoffStrategy, RetryConfig

  with UnifiedTo(
      security=shared.Security(
          jwt="<YOUR_API_KEY_HERE>",
      ),
  ) as unified_to:

      res = unified_to.accounting.create_accounting_account(request={
          "connection_id": "<value>",
      },
          RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False))

      assert res.accounting_account is not None

      
      print(res.accounting_account)

  ```

  If you'd like to override the default retry strategy for all operations that support retries, you can use the `retry_config` optional parameter when initializing the SDK:
  ```python
  from unified_python_sdk import UnifiedTo
  from unified_python_sdk.models import shared
  from unified_python_sdk.utils import BackoffStrategy, RetryConfig

  with UnifiedTo(
      retry_config=RetryConfig("backoff", BackoffStrategy(1, 50, 1.1, 100), False),
      security=shared.Security(
          jwt="<YOUR_API_KEY_HERE>",
      ),
  ) as unified_to:

      res = unified_to.accounting.create_accounting_account(request={
          "connection_id": "<value>",
      })

      assert res.accounting_account is not None

      
      print(res.accounting_account)

  ```
  <!-- End Retries [retries] -->

  <!-- Start Error Handling [errors] -->


  Handling errors in this SDK should largely match your expectations. All operations return a response object or raise an exception.

  By default, an API error will raise a errors.SDKError exception, which has the following properties:

  | Property        | Type             | Description           |
  |-----------------|------------------|-----------------------|
  | `.status_code`  | *int*            | The HTTP status code  |
  | `.message`      | *str*            | The error message     |
  | `.raw_response` | *httpx.Response* | The raw HTTP response |
  | `.body`         | *str*            | The response content  |

  When custom error responses are specified for an operation, the SDK may also raise their associated exceptions. You can refer to respective *Errors* tables in SDK docs for more details on possible exception types for each operation. For example, the `create_accounting_account_async` method may raise the following exceptions:

  | Error Type      | Status Code | Content Type |
  | --------------- | ----------- | ------------ |
  | errors.SDKError | 4XX, 5XX    | \*/\*        |



  ```python
  from unified_python_sdk import UnifiedTo
  from unified_python_sdk.models import errors, shared

  with UnifiedTo(
      security=shared.Security(
          jwt="<YOUR_API_KEY_HERE>",
      ),
  ) as unified_to:
      res = None
      try:

          res = unified_to.accounting.create_accounting_account(request={
              "connection_id": "<value>",
          })

          assert res.accounting_account is not None

          
          print(res.accounting_account)

      except errors.SDKError as e:
          
          raise(e)
  ```
  <!-- End Error Handling [errors] -->



  <!-- Start Server Selection [server] -->




  You can override the default server globally by passing a server index to the `server_idx: int` optional parameter when initializing the SDK client instance. The selected server will then be used as the default on the operations that use it. This table lists the indexes associated with the available servers:

  | #   | Server                      |
  | --- | --------------------------- |
  | 0   | `https://api.unified.to`    |
  | 1   | `https://api-eu.unified.to` |



  ```python
  from unified_python_sdk import UnifiedTo
  from unified_python_sdk.models import shared

  with UnifiedTo(
      server_idx=1,
      security=shared.Security(
          jwt="<YOUR_API_KEY_HERE>",
      ),
  ) as unified_to:

      res = unified_to.accounting.create_accounting_account(request={
          "connection_id": "<value>",
      })

      assert res.accounting_account is not None

      
      print(res.accounting_account)

  ```



  The default server can also be overridden globally by passing a URL to the `server_url: str` optional parameter when initializing the SDK client instance. For example:
  ```python
  from unified_python_sdk import UnifiedTo
  from unified_python_sdk.models import shared

  with UnifiedTo(
      server_url="https://api.unified.to",
      security=shared.Security(
          jwt="<YOUR_API_KEY_HERE>",
      ),
  ) as unified_to:

      res = unified_to.accounting.create_accounting_account(request={
          "connection_id": "<value>",
      })

      assert res.accounting_account is not None

      
      print(res.accounting_account)

  ```
  <!-- End Server Selection [server] -->



  <!-- Start Custom HTTP Client [http-client] -->


  The Python SDK makes API calls using the [httpx](https://www.python-httpx.org/) HTTP library.  In order to provide a convenient way to configure timeouts, cookies, proxies, custom headers, and other low-level configuration, you can initialize the SDK client with your own HTTP client instance.
  Depending on whether you are using the sync or async version of the SDK, you can pass an instance of `HttpClient` or `AsyncHttpClient` respectively, which are Protocol's ensuring that the client has the necessary methods to make API calls.
  This allows you to wrap the client with your own custom logic, such as adding custom headers, logging, or error handling, or you can just pass an instance of `httpx.Client` or `httpx.AsyncClient` directly.

  For example, you could specify a header for every request that this sdk makes as follows:
  ```python
  from unified_python_sdk import UnifiedTo
  import httpx

  http_client = httpx.Client(headers={"x-custom-header": "someValue"})
  s = UnifiedTo(client=http_client)
  ```

  or you could wrap the client with your own custom logic:
  ```python
  from unified_python_sdk import UnifiedTo
  from unified_python_sdk.httpclient import AsyncHttpClient
  import httpx

  class CustomClient(AsyncHttpClient):
      client: AsyncHttpClient

      def __init__(self, client: AsyncHttpClient):
          self.client = client

      async def send(
          self,
          request: httpx.Request,
          *,
          stream: bool = False,
          auth: Union[
              httpx._types.AuthTypes, httpx._client.UseClientDefault, None
          ] = httpx.USE_CLIENT_DEFAULT,
          follow_redirects: Union[
              bool, httpx._client.UseClientDefault
          ] = httpx.USE_CLIENT_DEFAULT,
      ) -> httpx.Response:
          request.headers["Client-Level-Header"] = "added by client"

          return await self.client.send(
              request, stream=stream, auth=auth, follow_redirects=follow_redirects
          )

      def build_request(
          self,
          method: str,
          url: httpx._types.URLTypes,
          *,
          content: Optional[httpx._types.RequestContent] = None,
          data: Optional[httpx._types.RequestData] = None,
          files: Optional[httpx._types.RequestFiles] = None,
          json: Optional[Any] = None,
          params: Optional[httpx._types.QueryParamTypes] = None,
          headers: Optional[httpx._types.HeaderTypes] = None,
          cookies: Optional[httpx._types.CookieTypes] = None,
          timeout: Union[
              httpx._types.TimeoutTypes, httpx._client.UseClientDefault
          ] = httpx.USE_CLIENT_DEFAULT,
          extensions: Optional[httpx._types.RequestExtensions] = None,
      ) -> httpx.Request:
          return self.client.build_request(
              method,
              url,
              content=content,
              data=data,
              files=files,
              json=json,
              params=params,
              headers=headers,
              cookies=cookies,
              timeout=timeout,
              extensions=extensions,
          )

  s = UnifiedTo(async_client=CustomClient(httpx.AsyncClient()))
  ```
  <!-- End Custom HTTP Client [http-client] -->



  <!-- Start Authentication [security] -->




  This SDK supports the following security scheme globally:

  | Name  | Type   | Scheme  |
  | ----- | ------ | ------- |
  | `jwt` | apiKey | API key |

  You can set the security parameters through the `security` optional parameter when initializing the SDK client instance. For example:
  ```python
  from unified_python_sdk import UnifiedTo
  from unified_python_sdk.models import shared

  with UnifiedTo(
      security=shared.Security(
          jwt="<YOUR_API_KEY_HERE>",
      ),
  ) as unified_to:

      res = unified_to.accounting.create_accounting_account(request={
          "connection_id": "<value>",
      })

      assert res.accounting_account is not None

      
      print(res.accounting_account)

  ```
  <!-- End Authentication [security] -->

  <!-- Start Debugging [debug] -->


  You can setup your SDK to emit debug logs for SDK requests and responses.

  You can pass your own logger class directly into your SDK.
  ```python
  from unified_python_sdk import UnifiedTo
  import logging

  logging.basicConfig(level=logging.DEBUG)
  s = UnifiedTo(debug_logger=logging.getLogger("unified_python_sdk"))
  ```
  <!-- End Debugging [debug] -->

  <!-- Placeholder for Future Speakeasy SDK Sections -->




  While we value open-source contributions to this SDK, this library is generated programmatically.
  Feel free to open a PR or a Github issue as a proof of concept and we'll do our best to include it in a future release!


