Saravanan666/pypi-org huggingface dataset:
Package: sdwi2iextender
sdwi2iextenderA python library to help create custom img2img operation modes in A1111.ContextConflicts can easily arise between different A1111 extensions when creating new operation modes in the img2img section.This library suggests an implementation that uniformalizes the creation of new operation modes.Installpip install sdwi2iextenderUsageRegistering a new operation modeBefore creating any UI or behavior, we need to register the operation mode.This is done in 2 steps for each new tab that we want to create.Step 1First, we need to extend theOperationModeclass:fromsdwi2iextenderimportOperationModeclassMyOperationMode(OperationMode):passStep 2Then, we can add the new operation mode to the list of operation modes by calling theregister_operation_modefunction:fromsdwi2iextenderimportOperationMode,register_operation_modeclassMyOperationMode(OperationMode):passregister_operation_mode(MyOperationMode)That's it! The new operation mode is now registered with the Webui.This won't do anything yet, though. We still need to populate our class with the behavior that we want.Populating an operation modeThere are a few methods that can be overriden, let's look at them one by one.tabThetabmethod is called with the Gradio context of the img2img tab group.This means that you can create a gradio tab in it, and it will be rendered with the other img2img operation modes:classMyTab(OperationMode):deftab(self,):self.tab=gr.TabItem(label='My new tab')As of version 0.0.1, you need exactly onegr.TabItemper operation mode.
Adding more than one tab per operation mode in thetab()method will result in an error.
Not defining the tab in thetab()method will result in an error.sectionThesectionmethod is called with the Gradio context of the inpaint parameters.You tipically use it to modify the inpaint parameters, add new ones, hide them, etc.classMyInpaintParams(OperationMode):defsection(self,components:list):passIgnore thecomponentslist for now, we'll look at it later for more complex examples.For now, here is how you can add a slider to the inpaint parameters:classMyInpaintParams(OperationMode):defsection(self,components:list):self.slider=gr.Slider(label="New slider")gradio_eventsThegradio_eventsmethod is called when all the new operation modes are finished being created in the UI.This is useful to setup any new event you want between Gradio components:classMyOperationMode(OperationMode):deftab(self):self.tab=gr.TabItem(label='My new tab')defsection(self,components:list):self.slider=gr.Slider(label="New slider")defgradio_events(self,img2img_tabs:list):self.tab.select(fn=lambdaslider_value:setattr(self,"slider_value",slider_value),inputs=[self.slider],outputs=[])This documentation is a WIPI encourage you to look at the source code if you want to learn more about how to use this library!
Package: sd-wireless-demo
Sound Designer Wireless DemoThis repository contains a Python-based wireless demo app using the Sound Designer SDK on Windows. It uses the amazingTextualframework to provide a console-based GUI.InstallationThe easiest and cleanest way to install this demo is withpipx:pipx install sd-wireless-demoYou can also install with pip (but it will install a bunch of dependencies directly into your Python environment):pip install sd-wireless-demoEither way, you will now have awireless_democommand on your path, which you can run in a terminal:$ wireless_demo -h
usage: wireless_demo [-h] [--sdk-root SDK_ROOT] [--noahlink-driver-path NOAHLINK_DRIVER_PATH] [--programmer {RSL10,NOAHLink}] [--com-port COM_PORT] [--debug] [--delete-bonds]

options:
  -h, --help            show this help message and exit
  --sdk-root SDK_ROOT   Path to the Sound Designer SDK root folder (or set "SD_SDK_ROOT" in your environment)
  --noahlink-driver-path NOAHLINK_DRIVER_PATH
                        Path to the NOAHLink Wireless drivers (when using NOAHLink wireless)
  --programmer {RSL10,NOAHLink}
                        The type of wireless programmer to use
  --com-port COM_PORT   The COM port to use when using the RSL10 dongle
  --debug               Log additional debug information to app_debug.log
  --delete-bonds        Delete the bond table in the wireless programmerUsageThis demo requires the Sound Designer SDK, which you can point to via the--sdk-rootcommand line argument. It also requires a wireless programmer. Currently supported devices are the RSL10 dongle fromonsemi, or the NOAHLink Wireless.Here is an example of what it looks like when connected to a pair of binaural hearing aids:
Package: sdx-common
Common classes for SDX apps. Contains a single package:sdx.commonsdx.commonA common library for SDX apps. App projects declare their dependence onsdx-commonwhich
is deployed and installed via pip.Basic useAssuming a Python 3.5 virtual environment at~/py3.5:Run the unit tests:~/py3.5/bin/python -m unittest discover sdxCreate a package for deployment:~/py3.5/bin/python setup.py sdistInstall source package with pip:~/py3.5/bin/pip install -U dist/sdx-common-x.y.z.tar.gzInstall extra dependencies for development and building documentation:~/py3.5/bin/pip install .[dev,docbuild]Build documentation pages:~/py3.5/bin/sphinx-build sdx/common/doc sdx/common/doc/html
Package: sdxl
Stable Diffusion XL ( API )Reverse engineered API of Stable Diffusion XL 1.0 ( Midjourney Alternative ) viahttps://replicate.com/, A text-to-image generative AI model that creates beautiful 1024x1024 images.Table of ContentsStable Diffusion XL ( API )PrerequisitesInstallationUsageSend Prompt to generate imageOutputExample Images GeneratedAdvanced Generation using parametersList of parametersCLI VersionDisclaimerLicensePrerequisitesTo use this API, you need to have the following:Python installed on your system
requests library installedpipinstallrequestsInstallationTo use the Claude AI Unofficial API, you can either clone the GitHub repository or directly download the Python file.Terminal :pip install sdxlorClone the repository:git clone https://github.com/KoushikNavuluri/stable-diffusion-xl-api.gitUsageImport the claude_api module in your Python script:from sdxl import ImageGeneratorNext, you need to create an instance of the ImageGenerator class:client=ImageGenerator()Send Prompt to generate imageimages=sdxl.gen_image("Vibrant, Headshot of a serene, meditating individual surrounded by soft, ambient lighting.")print(images)OutputExample Images GeneratedAdvanced Generation using parameters#Parameters set to their default valuesimages=sdxl.gen_image(prompt="Vibrant, Headshot of a serene, meditating individual surrounded by soft, ambient lighting.",count=1,width=1024,height=1024,refine="expert_ensemble_refiner",scheduler="DDIM",guidance_scale=7.5,high_noise_frac=0.8,prompt_strength=0.8,num_inference_steps=50)print(images)List of parameters*   prompt = Input text prompt
  *   width  = Width of output image(max:1024)
  *   height = height of output image(max:1024)
  *   count  = Number of images to output. (minimum: 1; maximum: 4) 
  *   refine = Which refine style to use ( no_refiner or expert_ensemble_refiner or base_image_refiner )
  *   scheduler = scheduler (valid_schedulers = ["DDIM" or "DPMSolverMultistep" or "HeunDiscrete" or "KarrasDPM" or "K_EULER_ANCESTRAL" or "K_EULER" or "PNDM"])
  *   guidance_scale = Scale for classifier-free guidance (minimum: 1; maximum: 50) 
  *   prompt_strength = Prompt strength in image (maximum: 1) 
  *   num_inference_steps = Number of denoising steps (minimum: 1; maximum: 500) 
  *   high_noise_frac = for expert_ensemble_refiner, the fraction of noise to use (maximum: 1)CLI VersionFor cli version you can check example folder in this repository (filename:cli.py)How to:pythonmain.py"beautiful landscape with two kittens,realistic,4k"--count1--width1024--height1024--refineexpert_ensemble_refiner--schedulerDDIM--guidance_scale7.5--high_noise_frac0.6--prompt_strength0.9--num_inference_steps40DisclaimerThis project provides an unofficial API for Replicate's Stable Diffusion XL and is not affiliated with or endorsed by Replicate or Stable Diffusion. Use it at your own risk.LicenseThis project is licensed under theMITLicense - see the LICENSE file for details.
Package: sdypy
SDyPy - Structural Dynamics PythonThis package has the goal to defragment the open source effort in the scientific field
of structural dynamics. Our goal is to speed-up the development and implementation of scientific
methods. This an open and free initiative, we stand up for:free MIT license,open development,open accepting of contributions,open decision making,multi-institutional engagement.SDyPy depends on core SciPy stack packages, please use those packages where possible. If you
would like an extension to be implemented, if it is general and not related to structural dynamics,
consider implementing it into the SciPy stack.Installation and basic usageInstall this package by:pip install sdypyThesdypyoffers a convenient way to access the functionality of the namespace packages.First import thesdypypackage:importsdypyassdAccess theEMAmodule:model=sd.EMA.Model(FRF_matrix,freq_array)or theiomodule:uff_obj=sd.io.uff.UFF('file.uff')or theFRFmodule:frf_obj=sd.FRF.FRF(sampling_freq,excitation,response)or theexcitationmodule:gausian_signal=sd.excitation.random_gaussian((N,PSD,fs))Package integration in SDyPyThe existing efforts in the field of structural dynamics are included in SDyPy according to
the level of integration (seeSEP 1).1st level(part of SDyPy repository or organization):sdypy-EMA(Experimental Modal Analysis in Python)sdypy-io(Input/Output for Structural Dynamics)sdypy-FRF(Frequency Response Function estimation)sdypy-excitation(Excitation signals as used in structural dynamics and vibration fatigue)2nd level(namespace package in independent repository):3rd level(packages that correspond to the SDyPy template):pyExSi(Excitation signal generator)FLife(Vibration fatigue life in the spectral domain)pyIDI(Image-Based Displacement Identification)4th level(these packages are developed completely independently but might be useful for 3rd, 2nd and 1st level packages):pyFRF(Frequency Response Function estimation)pyFBS(Frequency Based Substructuring and Transfer Path Analysis)speckle_pattern(Speckle pattern generation for DIC)pyUFF(Universal File Format in Python)pyNNST(Obtaining non-stationary index for time-series)python-acoustics(Useful tools for acousticians)pyTrigger(Software trigger for data acquisition)AMfe(Finite Element Research Code)
Package: sdypy-EMA
Experimental and operational modal analysisCheck out thedocumentation.This project is successor of thepyEMAproject. pyEMA is no longer developed after version 0.26.New in version 0.27UFF support: Import FRFs directly from UFF files. ThepyUFFpackage is used to read the UFF files.Stability chart upgrade: Show/hide unstable poles to improve the clarity of the chart.Documentation update.Basic usageImportEMAmodule:fromsdypyimportEMAMake an instance ofModelclass:a=EMA.Model(frf_matrix,frequency_array,lower=50,upper=10000,pol_order_high=60)Compute poles:a.get_poles()Determine correct poles:The stable poles can be determined in two ways:Displaystability charta.select_poles()The stability chart displayes calculated poles and the user can hand-pick the stable ones.If the approximate values of natural frequencies are already known, it is not necessary to display the stability chart:approx_nat_freq=[314,864]a.select_closest_poles(approx_nat_freq)After the stable poles are selected, the natural frequencies and damping coefficients can now be accessed:a.nat_freq# natrual frequenciesa.nat_xi# damping coefficientsReconstruction:There are two types of reconstruction possible:Reconstruction usingownpoles (the default option):H,A=a.get_constants(whose_poles='own')whereHis reconstructed FRF matrix andAis a matrix of modal constants.Reconstruction oncusing poles froma:c=EMA.Model(frf_matrix,frequency_array,lower=50,upper=10000,pol_order_high=60)H,A=c.get_constants(whose_poles=a)
Package: sdypy-excitation
Frequency response function as used in structural dynamics.Thesdypy-excitationis a namespace project of thesdypyframework and is a direct link
to thepyExSipackage (developed atpyExSi).Use thesdypypackage to conveniently access the functionality of thepyExSipackage through its namespace (see example below).Other functionalities of thesdypyframework include:sdypy-EMA: Experimental Modal Analysissdypy-io: Input/Output operations (LVM files, UFF files)sdypy-FRF: Frequency Response Function estimationFor more information check out the showcase examples and seedocumentation.Basicsdypy-excitationusage:Import the module:importnumpyasnp# import the sdypy moduleimportsdypyassdN=2**16# number of data points of time signalfs=1024# sampling frequency [Hz]t=np.arange(0,N)/fs# time vector# define frequency vector and one-sided flat-shaped PSDM=N//2+1# number of data points of frequency vectorfreq=np.arange(0,M,1)*fs/N# frequency vectorfreq_lower=50# PSD lower frequency limit  [Hz]freq_upper=100# PSD upper frequency limit [Hz]PSD=sd.excitation.get_psd(freq,freq_lower,freq_upper)# one-sided flat-shaped PSD#get gaussian stationary signalgausian_signal=sd.excitation.random_gaussian((N,PSD,fs))#get non-gaussian non-stationary signal, with kurtosis k_u=10#amplitude modulation, modulating signal defined by PSDPSD_modulating=sd.excitation.get_psd(freq,freq_lower=1,freq_upper=10)#define array of parameters delta_m and pdelta_m_list=np.arange(.1,2.1,.5)p_list=np.arange(.1,2.1,.5)#get signalnongaussian_nonstationary_signal=sd.excitation.nonstationary_signal(N,PSD,fs,k_u=5,modulating_signal=('PSD',PSD_modulating),param1_list=p_list,param2_list=delta_m_list)
Package: sdypy-FRF
Frequency response function as used in structural dynamics.Thesdypy-FRFis a namespace project of thesdypyframework and is a direct link
to thepyFRFpackage.Use thesdypypackage to convieniently access the functionallity of thepyFRFpackage through its namespace (see example below).Other functionalities of thesdypyframework include:sdypy-EMA: Experimental Modal Analysissdypy-io: Input/Output operations (LVM files, UFF files)For more information check out the showcase examples and seedocumentation.Basicsdypy-FRFusage:Import the module:fromsdypyimportFRFMake an instance ofFRFclass:a=FRF.FRF(sampling_freq,exc=None,resp=None,exc_type='f',resp_type='a',window='none',weighting='linear',fft_len=None,nperseg=None,noverlap=None,archive_time_data=False,frf_type='H1',copy=True)Adding data:We can add the excitation and response data at the beginning throughexcandresparguments, otherwise, the excitation and response
data can be added later viaadd_data()method:a.add_data(exc,resp)Computing FRF:Preferable way to get the frequency response functions is viaget_FRF()method:frf=a.get_FRF(type="default",form="receptance")We can also directly get the requested FRF via other methods:get_H1(),get_H2(),get_Hv()and,get_ods_frf():H1=a.get_H1()H2=a.get_H2()Hv=a.get_Hv()ods_frf=a.get_ods_frf()to test theShowcase.ipynb.
Package: sdypy-io
Read/write experimental and analysis data in the field of structural dynamics. Check out thedocumentation.Currently, theSDyPy-iopackage supports the reading and writing of the UFF (Universal File Format) files and reading of the LVM files.To use the package, install thesdypypackage:pipinstallsdypyTheiomodule is imported as follows:fromsdypyimportioUniversal File Format read and writeThe UFF class is defined to manipulate the UFF (Universal File Format) files.Currently supported UFF data-set types:15555858b8215116424112412241424202429LVM file formatThereadfunction parses the LVM file and returns a dictionary with the data.
Package: sdypy-io-tdms
SDyPy TDMS ioBasic package to import National Instruments .tdms files in a way complient with
SDyPy format for timeseries as proposed in SEP005.Using the packagefromsdypy_io_tdmsimportread_tdmsfile_path=# Path to the tdms file of interestsignals=read_tdms(file_path)
Package: sdypy-sep005
SDyPy SEP005 ComplianceThis package servers to asses the compability with the SDyPy proposal
for a unified timeseries model.Using the packageThe main function is theassert_sep005function that serves to
validate whether a function return is compliant with the current guidelines.It’s main use case is for the unittests of a custom import wrapperfromsdypy_sep005.sep005importassert_sep005signals=read_from_path(FILE_PATH)# Your import wrapperassert_sep005(signals)
Package: se360demo
Stat-Ease 360 and Python demoThis is a collection of a few Python programs that interact with Stat-Ease 360,
initially demonstrated at the 2021 DOE Summit by Hank Anderson. The slides
from that talk are included in this repository as well.In order to use the data from this repository, you should install these360demoPython package by runningpip install se360demo.Multi-response GraphThis uses theexamples\multiresponse-graph.pyscript. Open Stat-Ease 360 and
load this script from the Script Window, then click File -> Run.It will retrieve the two Analysis objects from SE360 and make predictions for
both of them while varying the A factor. These predictions are plotted on the
same Matplotlib plot.StreamflowThis example uses theexamples\streamflow.pyscript.It demonstrates fetching data from a cloud API and inserting it into
Stat-Ease 360. It has a flag in the script to toggle between live data and
a csv file.The data retrieval and manipulation code are inse360demo\__init__.py.
To use the live data you'll need to set an environment variable calledNOAA_TOKENwith a token generated fromhttps://www.ncdc.noaa.gov/cdo-web/token.Delivery TimeThis example uses theexamples\delivery-time.pyscript.This is the Delivery Time example from chapter 11.2.3 of Montgomery, Peck and
Vining (2012) on "data splitting" or cross validation. The data are first
segmented and evaluated according to the textbook. The data are then split into
4 segments for a k-fold cross validation. Each split is evaluated and the
results are plotted in a bar chart.Simulated Cross ValidationThis example uses theexamples\sim-cv.pyscript.This uses two data sets that both have simulated responses. The script compares
two analyses of each response using cross validation. One analysis is done using
Ordinary Least Squares and the other using a Gaussian Process Model.Streamflow Cross ValidationThis example uses theexamples\streamflow-cv.pyscript.This does a time-based cross validation on the streamflow data. It divides the
data up into years for one cross validation, then does another cross validation
based on the month of the year. The results are output to the console.
Package: se4ai-group4-common-utils
Group 4Common Utils packageCommon Utils PackageDependenciesPython packages to build:setuptoolsandwheelPython packages to deploy:twineTo install:python3 -m pip install --upgrade setuptools wheel twineBuilding & deploy the packagecd common-utilspython3 setup.py sdist bdist_wheelpython3 -m twine upload dist/*
Package: sea5kg-cpplint
sea5kg_cpplintNice configurable cpplint (c++ source code lint) on PythonHow to install:pip3 install sea5kg_cpplintHow to run:python3 -m sea5kg_cpplintfile with config for cpplintexample ofsea5kg_cpplint.config:# comment
line_length_limit = 80
check_copyright_in_files = yes
skip_files = src\.wsjcpp/.*
skip_files = tmp/.*config parametersline_length_limitinteger, how long line allowscheck_copyright_in_filesbool, check in files copyright commentskip_filesregexp, what files must be to skip
Package: seabass
# Screen Efficacy Analysis with BAyesian StatisticSSEABASS is a hierarchical linear mixed model for analysing CRISPR screen data. It can handle multiple time-points and replicates. It uses stochastic variational inference, implemented inpyroto fit model parameters. This enables using heavy-tailed noise distributions which provide a better fit to data and robustness to outliers.## Probabilistic modelThe probabilistic model for SEABASS is:guide_score ~ Normal(0, guide_std^2) for each guidelog2FC = (guide_score + guide_random_slope) * timepoint + noisenoise ~ D1(0, sigma_noise) for each observationguide_random_slope ~ D2(0, slope_noise) for each (guide,replicate) pairwhere guide_score is a slope and D1 and D2 are location-scale distributions which can be either normal, Cauchy, Laplace or StudentT.The noise standard deviation (std) can either be shared across guides (hierarchical_noise = False), or per guide but distributed according to a learned prior (hierarchical_noise = True):noise_std ~ logNormal(log_guide_std_mean,log_guide_std_std^2)Similarly slope_noise can either be shared shared guides (hierarchical_slope = False), or per guide but distributed according to a learned prior (hierarchical_noise = True):slope_noise ~ logNormal(log_sigma_noise_mean,log_sigma_noise_std^2)Additionally SEABASS can learn a per gene guide_std ~ logNormal(log_guide_std_mean, log_guide_std_std^2) to account for differences in essentiality.## UsageSeeexample_usage/example.ipynb
Package: seabird
This is a parser for Sea Bird CTD and TSG output files.TheSea Bird CTDpost processed data usually uses the .cnv extention. The purpose of the PySeabird is to parse this type of files, considering the different versions along the time, as well as different setups.At this point my goal is to have an object with the attributes parsed from the header, and the data as Masked Arrays, so that the user doesn’t need to loose time evaluating the version and details of that cnv, but have it in a standard pattern, ready to use.ATENTION, this is not an official package, so if you have trouble with it, do not complain to Sea-Bird. Open an issue at GitHub (https://github.com/castelao/seabird/issues), and I’ll try to help you.Support and DocumentationThe documentation is available atseabird.readthedocs.org.TheSeasoftmanual might be the best reference for the format used.If PySeabird doesn’t work with your .cnv files, send me a sample (just one .cnv) and I’ll fix to run it. The SeaBird changed the format several times along the time, so I need to see what do you have, to adjust PySeabird to work with it.Quick howto useTo install:pip install seabirdOne way to use is running on the shell the cnvdump. Independent of the historical version of the cnv file, it will return a default structure:seabird cnvdump your_file.cnvTo convert a .cnv (CTD output) into a NetCDF file, run:seabird cnv2nc your_file.cnvIn a python script, one can use like this:from seabird.cnv import fCNVprofile = fCNV(‘your_file.cnv’)profile.attrs # It will return the header, as a dictionary.profile.keys() # It will list the available variables.profile[‘TEMP2’] # If TEMP2 was on the .keys(), this is how you get the data. It will be a masked array.Check the example notebooks:http://nbviewer.ipython.org/github/castelao/seabird/tree/master/docs/notebooks/Licenseseabirdis licensed under a 3-clause BSD style license - see LICENSE.rstAuthorsGuilherme Castelão <guilherme@castelao.net> and Luiz Irber <luiz.irber@gmail.com>
Package: seabird-ctd
The Seabird CTD library communicates with, controls, and reads data directly off of a Seabird CTD. It has been designed for the legacy SBE 39 and the modern SBE 37+, but can be extended to support other models easily. Other CTD packages focus on working with the data, especially profiles, once it’s downloaded, but this package is designed to allow for direct control and monitoring during a longterm fixed deployment. The authors use this code to feed the CTD data into a database via django in realtime and implement the monitoring as a management command.In-development API documentation can be found athttps://seabird-ctd.readthedocs.io/en/latest/Installation documentation and examples of usage can be found athttps://bitbucket.org/b195m/seabird_ctd/Note that for installation, the package name is seabird-ctd (eg:pip install seabird-ctd), but when using, the package name is seabird_ctd.This package was developed by Nick Santos (https://nicksantos.com) for
Paul Cziko’s (https://paulcziko.com) McMurdo Oceanographic Observatory
under contract with the University of Oregon and funded by the National
Science Foundation under grant B-195-M.Contributions and extensions of the code to make it work with other models are invited and welcome.