Saravanan666/pypi-org huggingface dataset:
Package: pydm
PyDM: Python Display ManagerPyDM is a PyQt-based framework for building user interfaces for control systems.
  The goal is to provide a no-code, drag-and-drop system to make simple screens,
  as well as a straightforward Python framework to build complex applications.« Explore PyDMdocsandtutorials»Report bug·Request feature·How to Contribute·SupportPython Qt WrapperPyDM project uses theqtpyas the abstraction layer for the Qt Python wrappers (PyQt5/PyQt4/PySide2/PySide).All tests are performed with PyQt5.PrerequisitesPython 3.7+Qt 5.6 or higherqtpyPyQt5 >= 5.7 or any other Qt Python wrapper.Note:If you'd like to use Qt Designer (drag-and-drop tool to build interfaces) you'll
need to make sure you have the PyQt plugin for Designer installed.  This usually
happens automatically when you install PyQt from source, but if you install it
from a package manager, it may be left out.Python package requirements are listed in the requirements.txt file, which can
be used to install all requirements from pip: 'pip install -r requirements.txt'Running the TestsIn order to run the tests you will need to install some dependencies that are
not part of the runtime dependencies of PyDM.Assuming that you have cloned this repository do:pipinstall-rdev-requirements.txt

pythonrun_tests.pyIf you want to see the coverage report do:pythonrun_tests.py--show-covRunning the ExamplesThere are various examples of some of the features of the display manager.
To launch a particular display run 'python scripts/pydm '.There is a 'home' display in the examples directory with buttons to launch all
the examples:pythonscripts/pydmexamples/home.uiBuilding the Documentation LocallyIn order to build the documentation you will need to install some dependencies
that are not part of the runtime dependencies of PyDM.Assuming that you have cloned this repository do:pipinstall-rdocs-requirements.txtcddocs
makehtmlThis will generate the HTML documentation for PyDM at the<>/docs/build/htmlfolder. Look for theindex.htmlfile and open it with your browser.Online DocumentationDocumentation is available athttp://slaclab.github.io/pydm/.  Documentation is
somewhat sparse right now, unfortunately.Widget Designer Pluginspydm widgets are written in Python, and are loaded into Qt Designer via the PyQt
Designer Plugin.
If you want to use the pydm widgets in Qt Designer, add the pydm directory
(which holds designer_plugin.py) to your PYQTDESIGNERPATH environment variable.
Eventually, this will happen automatically in some kind of setup script.Easy Installing PyDMUsing the source codegitclonehttps://github.com/slaclab/pydm.gitcdpydm
pipinstall.[all]Using AnacondaWhen using Anaconda to install PyDM at a Linux Environment it will automatically
define the PYQTDESIGNERPATH environment variable pointing to /etc/pydm which
will have a file named designer_plugin.py which will make all the PyDM widgets
available to the Qt Designer. For more information please see
ourinstallation guide.
Package: pydmd
PyDMD is a Python package that uses Dynamic Mode Decomposition for a data-driven model simplification based on spatiotemporal coherent structures.Dynamic Mode Decomposition (DMD) is a model reduction algorithm developed by Schmid (see ‘Dynamic mode decomposition of numerical and experimental data’).  Since then has emerged as a powerful tool for analyzing the dynamics of nonlinear systems. DMD relies only on the high-fidelity measurements, like experimental data and numerical simulations, so it is an equation-free algorithm. Its popularity is also due to the fact that it does not make any assumptions about the underlying system. See Kutz (‘Dynamic Mode Decomposition: Data-Driven Modeling of Complex Systems’) for a comprehensive overview of the algorithm and its connections to the Koopman-operator analysis, initiated in Koopman (‘Hamiltonian systems and transformation in Hilbert space’), along with examples in computational fluid dynamics.In the last years many variants arose, such as multiresolution DMD, compressed DMD, forward backward DMD, and higher order DMD among others, in order to deal with noisy data, big dataset, or spurius data for example.In PyDMD we implemented the majority of the variants mentioned above with a user friendly interface.The research in the field is growing both in computational fluid dynamic and in structural mechanics, due to the equation-free nature of the model.
Package: pydmdll
Welcome to pydmdll前言Python模拟鼠标键盘的包有很多，它们的文档也很全，功能也很人性化，最后实在没有办法了再使用大漠。推荐结合使用：比如：大漠没有监听键盘的功能，你完全可以再开一个线程，使用Keyboard进行监听。Pyautogui侧重于鼠标，键盘，截图，消息框的功能Pywinauto侧重对CS的操作，对进程，窗体进行操作Keyboard侧重于键盘，监听键盘，设置热键，键盘记录等功能简介pydmdll仅支持32位Python，实现了大漠插件免费功能部分，内部封装的是V3.1233版本的dm.dll.初衷是为了解决鼠标在游戏内部无法拖拽的问题。项目Github在线文档功能键盘鼠标：输入，输出，按键，点击等窗口功能：最小化，激活，移动，获取窗口句柄等基本功能：剪贴板，蜂鸣器等安装pip install pydmdll开始import os
import time
from pydmdll import DM

if __name__ == '__main__':
    dm = DM()
    # dm = DM(dll_path="你自己的版本路径-绝对路径")
    # 取消注册
    # dm.Un_reg()

    # 打开记事本
    os.system("start notepad.exe")
    time.sleep(1)

    # 窗口句柄就是一个int类型的数字
    txt_hwnd = dm.FindWindow("", "记事本")
    print(txt_hwnd)

    # 最大化指定窗口,同时激活窗口.
    f = dm.SetWindowState(txt_hwnd, 4)
    # print(f)

    # 使记事本窗口移动
    dm.MoveWindow(txt_hwnd, 10, 10)

    print("GetWindowProcessPath",dm.GetWindowProcessPath(txt_hwnd))

    print("dm.GetWindowState(txt_hwnd,1)",dm.GetWindowState(txt_hwnd,4))

    # 打印注册路径
    path = dm.GetBasePath()
    print(path)

    # 获取剪贴板
    print(dm.GetClipboard())

    # 获取标题还有.py的所有句柄
    # 注意：返回的是str，但句柄必须是int类型，要强行转化
    # hwnd_str_list=dm.EnumWindow(0,".py","",1+2+4+8).split(",")
    # print(hwnd_str_list)
    # for hwnd in hwnd_str_list:
    #     print(dm.GetWindowClass(int(hwnd)))
    #     print(dm.GetWindowProcessPath(int(hwnd)))
    #     print(dm.GetWindowTitle(int(hwnd)))
    #     dm.MoveWindow(int(hwnd),100,100)

    # 推荐相对移动
    dm.MoveR(40, 10)注意在线程里面使用dm，要注意初始化pythoncom，否则每次都要注册DM，单线程情况下不用设置。

import pythoncom
pythoncom.CoInitialize()
dm = DM()


管理员运行cmd命令，/C代表打开执行之后直接关闭
注意cmd会直接运行你传入的命令，如果你使用/K 参数保留命令行，不会显示你传入的命令，但确实已经执行了，如果有回显你才会看到

ctypes.windll.shell32.ShellExecuteW(None, "runas", "cmd.exe", "/C %s" % self.cmd_un_dll, None, 1)

管理员运行本程序代码，通常在最开始执行，即整个代码以管理员运行

ctypes.windll.shell32.ShellExecuteW(None, "runas", sys.executable, __file__, None, 1)其他pydmdll仅仅封装了免费接口，默认使用的是内部封装的是V3.1233版本的dm.dll，也可以指定本地的dm.dll。大漠插件是用vb语言写的一个闭源且收费的的dll，V3.1233是其最后一个免费的版本，当然也仅是免费使用部分功能。键盘key_str虚拟键码"1",49"2",50"3",51"4",52"5",53"6",54"7",55"8",56"9",57"0",48"-",189"=",187"back",8"a",65"b",66"c",67"d",68"e",69"f",70"g",71"h",72"i",73"j",74"k",75"l",76"m",77"n",78"o",79"p",80"q",81"r",82"s",83"t",84"u",85"v",86"w",87"x",88"y",89"z",90"ctrl",17"alt",18"shift",16"win",91"space",32"cap",20"tab",9"~",192"esc",27"enter",13"up",38"down",40"left",37"right",39"option",93"print",44"delete",46"home",36"end",35"pgup",33"pgdn",34"f1",112"f2",113"f3",114"f4",115"f5",116"f6",117"f7",118"f8",119"f9",120"f10",121"f11",122"f12",123"[",219"]",221"\",220";",186"'",222",",188".",190"/",191
Package: pydme
PyDMEWarningDo not usebefore at least version 1.0.0. There will probably be a lot of incompatible changes in the beginning.PurposeIt is based ondolphin-memory-engine, having it as a dependency and adding a few wrapper functions, but the point is to put together one big package that merges the functionality ofthatand the JIT Cache refreshing its author has implemented in a different project.
Package: py-dmidecode
py-dmidecodeSmall tool that parses output of dmidecode commandHow to usefromdmidecodeimportDMIDecode# create parsing instance by passing dmidecode outputdmi=DMIDecode()# some of the pre-defined queriesprint('Manufacturer:\t',dmi.manufacturer())print('Model:\t\t',dmi.model())print('Firmware:\t',dmi.firmware())print('Serial number:\t',dmi.serial_number())print('Processor type:\t',dmi.cpu_type())print('Number of CPUs:\t',dmi.cpu_num())print('Cores count:\t',dmi.total_enabled_cores())print('Total RAM:\t{}GB'.format(dmi.total_ram()))Alternatively instead of running dmidecode locally you can use DMIParse by passing dmidecode output as an argument:fromdmidecodeimportDMIParsedmi=DMIParse(raw)Other information can be easily retrieved by analyzing dmi.data and module code.Possible limitationsTested with dmidecode versions 2.11, 2.12 and 3.2
Package: pyDML
pyDMLDistance Metric Learning Algorithms for PythonWhat is Distance Metric Learning?Many machine learning algorithms need a similarity measure to carry out their tasks. Usually, standard distances, like euclidean distance, are used to measure this similarity. Distance Metric Learning algorithms try to learn an optimal distance from the data.How to learn a distance?There are two main ways to learn a distance in Distance Metric Learning:Learning a metric matrix M, that is, a positive semidefinite matrix. In this case, the distance is measured asLearning a linear map L. This map is also represented by a matrix, not necessarily definite or squared. Here, the distance between two elements is the euclidean distance after applying the transformation.Every linear map defines a single metric (M = L'L), and two linear maps that define the same metric only differ in an isometry. So both approaches are equivalent.Some applicationsImprove distance based classifiersImproving 1-NN classification.Dimensionality reductionLearning a projection onto a plane for the digits dataset (dimension 64).DocumentationSee the available algorithms, the additional functionalities and the full documentationhere.StatsThe distance metric learning algorithms in pyDML are being evaluated in several datasets. The results of these experiments are available in thepyDML-Statsrepository.InstallationPyPI latest version:pip install pyDMLFrom GitHub: clone or download this repository and run the commandpython setup.py installon the root directory.AuthorsJuan Luis Suárez Díaz (jlsuarezdiaz)
Package: pydmm
PyDMMfacilitates reading data from a digital multimeter (DMM).
It works for example withHP-90EPC.
Typical usage looks like this:import pydmm.pydmm as pd

try:
    number = pd.read_dmm(port=myport, timeout=3)
    print(number)
except:
    print("Error")Preparationsinstall pyserialinstall pydmm (this module)connect the DMM to the usb-port of your computerfind out, which COM-port the device usesuse the port numbermyport(COM3 has number 2) when calling read_dmm()
Package: pydmo
pydmoDocumentation:https://strayMat.gitlab.io/pydmoSource Code:https://gitlab.com/strayMat/pydmoThis projects implements the creation of [pydantic] data models from a collection of dataset (eg. pandas dataset).MotivationHaving typed data models in python files is very useful for :Code testing thanks to dummy data generationData validationDocumentation generationThese usages are motivated by thedata templates with pydanticblog post.Links with other projectsTheTable-schema-translatortakes yaml as input to generate scala data models for spark.We use thepydantic code generation package.The python API should be installed with pip asrecommanded in the documentation.📝NoteMight be useful if we want to integrate some features existing only on table schema:Pandas api for table schema
Package: pyd-mon
Pyd_MonAn easy way to convert and validate Pymongo ObjectId's with Pydantic model fields.UsageCreating a MongoModelCreating Pydantic models with a mapping id is as easy as inheriting from MongoModel and creating anidfield with type ofMongoId. All of your other fields can be created as normal pydantic fields.frompyd_monimportMongoModel,MongoIdclassItem(MongoModel):id:MongoId# Will map to '_id'name:str# The rest of the fields are standard Pydantic fieldsCreate Pydantic instance from Pymongo dict (_id->id)To map from a Pymongo dict you can use thefrom_mongoclass method on your model.result=collection.find_one()# Get item from Pymongoitem=Item.from_mongo(result)# Create a Pydantic instance from the Pymongo dict.Create Pymongo dict from Pydantic instance (id->_id)To map back from a pydantic instance to a Pymongo dict call themongomethod on your model instance.item=Item(id=MongoId(),name='Example')collection.insert_one(item.mongo())
Package: pydmsoft
一個使用Python封裝大漠插件的庫這個模組是為了封裝大漠7.2213版本，並封裝了大漠插件的API，以便讓IDE都可以有代碼提示。這些方法是從大漠插件DLL的倒出函數，生成的Python方法，因為目前沒有看到封裝比較完整python調用大漠的Libary，便有了這個。安裝pip install pydmsoft功能初始化# 已在系統註冊大漠調用
dm = DM()
# 使用免註冊調用 只需要在第一次調用一次即可 其餘的可直接使用 dm=DM()
dm = DM(DmRegPath="path_to_dmreg.dll", DMPath="path_to_dm.dll")導入from pydmsoft import DM使用範例註冊dm = DM()
result = dm.Reg(code, Ver)
print(result)OCR 辨識dm = DM()
result = dm.Ocr(0, 0, 100, 100, "ffffff-000000", 0.9)
print(result)尋找文字dm = DM()
result = dm.FindStr(0, 0, 500, 500, "example", "ffffff-000000", 0.9)
print(result)截圖dm = DM()
dm.Capture(0, 0, 200, 200, "screenshot.png")模擬鍵盤操作dm = DM()
# 按下 'A' 鍵
dm.KeyPress(65)部分找圖找色可使用wait_until(等待秒數,間隔)try:
     print(m_dm.Reg('xxxx','xxx'))
     print(m_dm.FindColor(0,0,100,100,"ffffff",0.9,0).wait_until(5))
     print(m_dm.FindColorE(0,0,100,100,"ffffff",0.9,0).wait_until(5))
     print(m_dm.FindMultiColorE(0,0,100,100,"ffffff-000000",0.9,0,0).wait_until(10))
 except TimeOutException as e:
     print(e)注意事項請確保大漠的dll檔案和註冊檔案路徑正確。另外，當使用免註冊調用時，需同時提供DmRegPath和DMPath。開發者資訊這是一個開源的封裝項目，歡迎貢獻及提供建議。
Package: pydmsp
This is a simple converter for the source files of theDMSPdetectorSSJ/4.This package provides 3 modules for use:from_gzmake_datasettransform_datasetThe features of these modules are described below.Theunzip(filepath, mode='to_file')function of thefrom_gzmodule unpacks the gz-archive. The first parameter of the function takes the path to the file. The second parameter must specify the unpacking mode.Two unpacking modes are available: "to_file" (default) and "to_ram".When the "to_file" mode is selected, the function creates a new binary file in the archive directory with the archive name, removing its extension.When the "to_ram" mode is selected, the function returns the contents of the archive - a set of bytes.Themake_xr_dataset(filepath)function of themake_datasetmodule parses binary data, forming a set of source data from a binary DMSP file.The input parameter for the function is the path to the archive file with the "gz" extension.The function returns a set of source data that requires conversion to physical quantities. The type of the returned value isxarray.core.dataset.Dataset(i.e. thexarray libraryis used).Themake_transform_dataset(filepath)function of thetransform_datasetmodule parses binary data, forming a set of transformed data from a binary DMSP file.The input parameter for the function is the path to the archive file with the "gz" extension.The function returns a set of dataconverted to physical quantities. The type of the returned value isxarray.core.dataset.Dataset(i.e. thexarray libraryis used).
Package: pydnameth
pydnamethDNA Methylation Analysis PackageThis package provides some pipelines for analysis mythylation data.
The main goal is to find correlations between methylation on the one hand,
and age, sex, disease, and other characteristics of subjects on the other.Examples of free-access methylation datasets:GSE40279GSE87571DocumentationAvailable athttps://pydnameth.readthedocs.io.FeaturesDefining best age-predictors CpGs for different subjects subsets.Defining best observable-specic CpGs (sex-specific, disease-specific) which are differently methylated with age.Building Epigenetic Clock.Plotting subjects distribution depending on the observable (sex, disease).Plotting methylation profiles for CpGs.CopyrightsFree software: MIT licenseHistory0.2.4 (2019-11-06)Project encapsulating.0.1.0 (2019-01-24)First release on PyPI.
Package: pyDNase
IntroductionpyDNase is a suite of tools for analysing DNase-seq data - pyDNase comes with several analysis scripts covering several common use cases of DNase-seq analysis, and also an implementation of the Wellington, Wellington 1D, and Wellington-boostrap footprinting algorithms.An easy-to-understand DNase-seq footprinting tutorial can be foundhereand full documentation can be accessedhereAPIMany people currently analyzing DNase-seq data are using tools designed for ChIP-seq work, but may be inappropriate for DNase-seq data where one is less interested in the overlaps of sequenced fragments, but the site at which the cut occurs (the 5’ most end of the aligned sequence fragment).pyDNase has an underlying API to interface with a sorted and indexed BAM file from a DNase-seq experiment, allowing efficient and easy random access of DNase-seq cut data from any genomic location, e.g.>>> import pyDNase
>>> reads = pyDNase.BAMHandler(pyDNase.example_reads())
>>> reads["chr6,170863500,170863532,+"]
{'+': [0,0,0,1,0,0,1,1,2,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1,0,0,1,1,0,0,0,1],
 '-': [0,10,1,0,1,0,4,9,0,1,0,2,1,0,0,0,0,0,3,0,6,3,0,0,0,1,1,1,3,0,3,6]}Querying theBAMHandlerobject returns a dictionary containing lists with DNase cut counts on the positive reference strand (+), and cuts on the negative reference strand (-). pyDNase efficiently caches the cut data queried, so that multiple requests from the same genomic locations do not require repeated lookups from the BAM file (this can be disabled). See the full documentation for full details.Installationto install pyDNase, run:$ pip install pyDNasefor full documentation go to:http://pythonhosted.org/pyDNase/SupportIf you’re having any troubles, please send an email toj.piper@me.comand I’ll do my best to help you out. If you notice any bugs, then please raise an issue over at the github repo. If you require more formal training on the analysis of DNase-seq or ATAC-seq data, I am available for consultancy. Likewise, if you are a commercial entity looking for a support contract, please get in touch.ContributionsI highly encourage contributions! This is my first software development project - send any pull requests this way. I’m particularly interested in cool analysis scripts that anyone has written.ReferenceNoteIf you use pyDNase or the Wellington algorithm in your work, please cite the following papers.Piper et al. 2013.Wellington: A novel method for the accurate identification of digital genomic footprints from DNase-seq data, Nucleic Acids Research 2013; doi: 10.1093/nar/gkt850Piper et al. 2015.Wellington-bootstrap: differential DNase-seq footprinting identifies cell-type determining transcription factors, BMC Genomics 2015; doi:10.1186/s12864-015-2081-4LicenseCopyright (C) 2015 Jason Piper. This work is licensed under the MIT license, seeLICENCE.TXTfor details. If you require the use of this software under a difference license, please email me atj.piper@me.com.
Package: pydngconverter
PyDNGConverterPython Interface for the Adobe's DNG Converter.Utilizing parallel processing,
PyDNGConverter can convert RAW images to DNG up to~60% fasterthan simply utilizing Adobe's DNG Converter.Installationpipinstall-UpydngconverterTo utilize PyDNGConverter's Exif thumbnail extraction (as opposed to Adobe DNG Converters'), the following dependencies are required:ExifToolImageMagickThen specifyJPEGPreview.EXTRACTforDNGConvertersjpeg_previewparameter.Alternatively, you can utilize Adobe DNG Converters' thumbnail extraction via:JPEGPreview.MEDIUMJPEGPreview.FULLOr, disable thumbnails via:JPEGPreview.NONEExampleimportasynciofrompydngconverterimportDNGConverter,flagsasyncdefmain():# Create converter instance.pydng=DNGConverter('/my/raw/files/',dest='/dngfiles',jpeg_preview=flags.JPEGPreview.EXTRACT,fast_load=True,)# Convert allreturnawaitpydng.convert()loop=asyncio.get_event_loop()loop.run_until_complete(main())loop.close()
Package: pydnn
pydnn is a deep neural network library written in Python usingTheano(symbolic math and optimizing compiler package).  I wrote it as a learning project while competing inKaggle’s National Data Science Bowlin March 2015 (where it produced an entry finishing in thetop 6%) and plan to continue developing it by adding support for the most important deep learning techniques (including RNNs).Design GoalsSimplicityWherever possible simplify code to make it a clear expression of underlying deep learning algorithms.  Minimize cognitive overhead, so that it is easy for someone who has completed thedeeplearning.net tutorialsto pickup this library as a next step and easily start learning about, using, and coding more advanced techniques.CompletenessInclude all the important and popular techniques for effective deep learning andnottechniques with more marginal or ambiguous benefit.Ease of useMake preparing a dataset, building a model and training a deep network only a few lines of code; enable users to work with NumPy rather than Theano.PerformanceShould be roughly on par with other Theano neural net libraries so that pydnn is a viable choice for computationally intensive deep learning.FeaturesHigh performance GPU training (courtesy of Theano)Quick start tools to instantly get started training oninexpensiveAmazon EC2 GPU instances.Implementations of important new techniques recently reported in the literature:Batch NormalizationParametric ReLUactivation function,AdamoptimizationAdaDeltaoptimizationetc.Implementations of standard deep learning techniques:Stochastic Gradient Descent with MomentumDropoutconvolutions with max-pooling using overlapping windowsReLU/Tanh/sigmoid activation functionsetc.UsageFirst download and unzip raw image data from somewhere (e.g. Kaggle). Then:import pydnn
import numpy as np
rng = np.random.RandomState(e.rng_seed)

# build data, split into training/validation sets, preprocess
train_dir = 'home\ubuntu\train'
data = pydnn.data.DirectoryLabeledImageSet(train_dir).build()
data = pydnn.preprocess.split_training_data(data, 64, 80, 15, 5)
resizer = pydnn.preprocess.StretchResizer()
pre = pydnn.preprocess.Rotator360(data, (64, 64), resizer, rng)

# build the neural network
net = pydnn.nn.NN(pre, 'images', 121, 64, rng, pydnn.nn.relu)
net.add_convolution(72, (7, 7), (2, 2))
net.add_dropout()
net.add_convolution(128, (5, 5), (2, 2))
net.add_dropout()
net.add_convolution(128, (3, 3), (2, 2))
net.add_dropout()
net.add_hidden(3072)
net.add_dropout()
net.add_hidden(3072)
net.add_dropout()
net.add_logistic()

# train the network
lr = pydnn.nn.Adam(learning_rate=pydnn.nn.LearningRateDecay(
            learning_rate=0.006,
            decay=.1))
net.train(lr)From raw data to trained network (including specifying
network architecture) in 25 lines of code.Short Term GoalsImplement popular RNN techniques.Integrate with Amazon EC2 clustering software (such asStarCluster).Integrate with hyper-parameter optimization frameworks (such asSpearmintandhyperopt).AuthorsIsaac Kriegman
Package: pydnp3
pydnp3Python bindings for theopendnp3library,  an open source
implementation of theDNP3protocol stack written in C++14.Note:  This is a work in progress.  SeeIssuesfor things we know about and feel free to add your own.Supported Platforms:Linux, MacOSDependenciesTo build the library from source, you must have:A toolchain with a C++14 compilerCMake >= 2.8.12 (https://cmake.org/download/)This repository includes two repositories as submodules (underdeps/):dnp3 (https://github.com/automatak/dnp3)pybind11 (https://github.com/Kisensum/pybind11) - This is a fork containing a minor patch
required to compile some of the pydnp3 wrapper code. It will be replaced with pybind11 proper
when the issue is resolved.Build & InstallAt the moment, this library must be built from source:$ clone --recursive http://github.com/Kisensum/pydnp3
    $ cd pydnp3
    $ python setup.py installDocumentationpydnp3 is a thin wrapper around most all of the opendnp3 classes.  Documentation for the opendnp3
classes is available atautomatak.Use python's help to discover the available wrapper classes and functions.  For example,> import pydnp3
> help (pydnp3.opendnp3)
Help on module pydnp3.opendnp3 in pydnp3:

NAME
    pydnp3.opendnp3 - Bindings for opendnp3 namespace

FILE
    (built-in)

CLASSES
    pybind11_builtins.pybind11_object(__builtin__.object)
        AnalogCommandEvent
        AnalogInfo
            AnalogSpec
...