semvec/pypi-packages huggingface dataset:
dicomtocnn 1
Python Library to handle Input / Output conversion in Dicom <=> Convolutional Neural Network
Requires Python: >=3.7

# library-DICOM

Features : 
- Description of Series content in a huge dataset of DICOM (output JSON descriptor for each series containings main DICOM tags).
- Conversion Dicom to Nifti
- PET : Conversion Bqml/Counts to SUV and SUL

Roadmap : 
- Read RTSS to generate Mask
- Generate RTSS from Mask
- PT / CT fusion in 4D array np array

#Maintainer  : Salim Kanoun
#Contributors : Thomas Trouillard, Wendy Revailler



To refactor : 
- conversion of a nifti mask to a ROI in a DICOM RTSTRUCT
- ROI integration to an existing RTSTRUCT
- generation empty RTSTRUCT from PET,CT or similar set of DICOM images

**TODO :** 
- conversion DICOM RTSTRUCT to mask in nifti format
Zapurl 0.2.0
A tool that allows you to connect directly to ZapURL to shorten link through Python.
Keywords: URL,Shortener,ZapURL

# ZapURL
The ZapURL package allows you to shorten your links directly through Python.

# Usage
Here is how you can shorten your URL.

```python
Zapurl.short([PUT_YOUR_URL_HERE]) # Shorten a URL with random directory
```
```python
Zapurl.custom(url, email, name, custom_directory) # Create custom URLs
```
```python
Zapurl.about() # Returns ZapURL build info
```
```python
Zapurl.site() # Gives you the official ZapURL site.
```
```python
Zapurl.latest() # Returns the latest version of ZapURL, download size, how to install it, and other information.
```
```python
Zapurl.update() # Updates your module automatically for you
```

# Upcoming
More features will be coming soon. 
- No new features planned yet. (Even if there were, we aren't telling you!)


# Change Log

## v0.0.1 (2/3/2021)
- First Release

## v0.1.0 (2/9/2021)
- Support for new security measure in ZapURL
- Custom URL Shortening enabled
- Package Build Version and Info
- Latest version function
- Shows Official Site Function


## v0.1.1 (2/9/2021)
- Bug fixed where classic short could display extra `<` character at end resulting in link issues.

## v0.2.0 (2/10/2021)
- Bug fixes and Improvements.
- This is the most stable version of ZapURL
- Bug where ZapURL displayed wrong version number in .about() function.
- Release date displaying weird fixed. 
- Connecting to Update Server bug is fixed.
- Error Reporting added, which tells you when a URL is taken or not.
- Site and server information is now an added feature.
- Bug where ZapURL is ot displaying an important module of our updating system is fixed.
- New diologue added during package updating.
- This version is going to be the base of which all our future versions will be built off of.
pyopenset 0.0.12
Infering novel classes for classification problems
Requires Python: >=3.5

# pyopenset

Pyopenset is a package that implements the meyhodology described in the paper:

It allows a easy and intuitive way to add novel classes to a pretrained model without requiring further optimization, New classes will always be added after the last.

So for example if your model has 10 neurons each for a single class ,the new class would be associated with neuron 11.

Note that current implementation only supports softmax activation functions on the last layer.
ChimuApi 0.1.5
API Wrapper around Chimu.moe API for both synchronous and asynchronous purposes.
Requires Python: >=3.6

# ChimuAPI Python Wrapper
API Wrapper around Chimu.moe API for both synchronous and asynchronous purposes.

## What is it for?
I made this wrapper for Python devs so they can easly access Chimu.moe API both async and sync.

Allowing more people to use it!

## Synchronous Example

```py
import ChimuApi as chimu

def main():

    api = chimu.ChimuAPI()

    sets = api.get_set(1)

    for mapa in sets.ChildrenBeatmaps:

        print(f"{mapa.BeatmapId} [{mapa.DiffName}]")
    
    print(sets.Creator)

def download():

    api = chimu.ChimuAPI()

    file_bytes = api.download_file(1, key_here, state_here)

    with open("map.osz", "wb") as filea:
        filea.write(file_bytes)

main()
download()
```

## Asynchronous Example

```py
import ChimuApi as chimu
import asyncio

async def main():

    api = chimu.AsyncChimuAPI()

    sets = await api.get_set(1)

    for mapa in sets.ChildrenBeatmaps:

        print(f"{mapa.BeatmapId} [{mapa.DiffName}]")
    
    print(sets.Creator)

async def download():

    api = chimu.AsyncChimuAPI()

    file_bytes = await api.download_file(1, key_here, state_here)

    with open("map.osz", "wb") as filea:
        filea.write(file_bytes)

asyncio.run(main())
asyncio.run(download())
```

## Contribution
If you feel like you want to help/fix/change something in this package,
just create Issue or Pull Request on GitHub and I'll review it.
countingworkspace 0.2.3
Simple builder for counting experiment RooFit workspace

[![Build Status](https://travis-ci.org/wiso/countingworkspace.svg?branch=master)](https://travis-ci.org/wiso/countingworkspace)
[![Coverage Status](https://coveralls.io/repos/github/wiso/countingworkspace/badge.svg?branch=master)](https://coveralls.io/github/wiso/countingworkspace?branch=master) 
[![PyPI version](https://badge.fury.io/py/countingworkspace.svg)](https://badge.fury.io/py/countingworkspace)

# CountingWorkspace

Very simple python package to create very simple counting experiment RooFit workspaces.

The statistical model describes the migration of events from truth-bins (e.g. processes) and reco-category. The implemented likelihood is a product of Poissonian distributions:

<img src="https://raw.githubusercontent.com/wiso/countingworkspace/master/imgs/formula1.png" width="30%"/>

The product is over all the reconstructed categories. The number of expected events in each category is:

<img src="https://raw.githubusercontent.com/wiso/countingworkspace/master/imgs/formula3.png" width="60%"/>

The matrix ε implements the efficiencies and the migrations. It's matrix elements are the conditional probability to be selected and reconstructed in category-c for a process-p: P[c|p].
The generated number of events for each process can be parametrized in any way. A popular one in hep is:

<img src="https://raw.githubusercontent.com/wiso/countingworkspace/master/imgs/formula2.png" width="60%"/>

here the generated number of events are equal to the product of the luminosity (the overall normalization), its cross section and the signal strength (which is the free parameter in the fit). The background is added on top of that.

Here a simple example:

```python
import ROOT
from countingworkspace import *

NAMES_PROC = ['proc1', 'proc2']
NCATEGORIES = 3
EFFICIENCIES = [[0.3, 0.1],
                [0.5, 0.4],
                [0.2, 0.2]]
EXPECTED_BKG_CAT = [100, 30, 10]
LUMI = 100.
# first create the parameters needed for the parametrization. The luminosity
ws = ROOT.RooWorkspace()
ws.factory('lumi[%f]' % LUMI)
# and the cross sections:
xsections = create_variables(ws, 'xsec_{proc}',     # {proc} is an index, you can call as you prefer
                             bins=NAMES_PROC,       # the names
                             values=[101.5, 7.99])  # the values of the cross sections
create_workspace(NCATEGORIES, NAMES_PROC,
                 efficiencies=EFFICIENCIES,
                 nexpected_bkg_cat=EXPECTED_BKG_CAT,
                 expression_nsignal_gen='prod:nsignal_gen_proc{proc}(mu_{proc}[1, -4, 5], lumi, xsec_{proc})',
                 ws=ws)                         
                         
```

It is also possible to add simple systematic uncertainties.

There are some utilies to run toys.

Look at the [examples](examples)

## Installation

    pip install countingworkspace