Saravanan666/pypi-org huggingface dataset:
Package: ffpack
FFPACK - Fatigue and Fracture PACKagePurposeFFPACK( Fatigue and Fracture PACKage ) is an open-source Python library for fatigue and fracture analysis. It supports ASTM cycle counting, load sequence generation, fatigue damage evaluation, etc. A lot of features are under active development.FFPACKis designed to help engineers analyze fatigue and fracture behavior in engineering practice.InstallationFFPACKcan be installed viaPyPI:pipinstallffpackUsageThe following example shows the usage of ASTM rainflow counting,# Import the ASTM rainflow counting functionfromffpack.lccimportastmRainflowCounting# Prepare the datadata=[-2.0,1.0,-3.0,5.0,-1.0,3.0,-4.0,4.0,-2.0]# Get counting resultsresults=astmRainflowCounting(data)See the package document for more details and examples.StatusFFPACKis currently under active development.ContentsFatigue damage modelPalmgren-miner damage modelNaive Palmgren-miner damage modelClassic Palmgren-miner damage modelLoad counting and correctionASTM countingASTM level crossing countingASTM peak countingASTM simple range countingASTM range pair countingASTM rainflow countingASTM rainflow counting for repeating historyJohannesson countingJohannesson min max countingRychlik countingRychlik rainflow countingFour point countingFour point rainflow countingMean stress correctionGoodman correctionSoderberg correctionGerber correctionLoad sequence generatorRandom walkUniform random walkAutoregressive moving average modelNormal autoregressive (AR) modelNormal moving average (MA) modelNormal ARMA modelNormal ARIMA modelSequence from spectrumSpectral representationLoad spectra and matricesCycle counting matrixASTM simple range counting matrixASTM range pair counting matrixASTM rainflow counting matrixASTM rainflow counting matrix for repeating historyJohannesson min max counting matrixRychlik rainflow counting matrixFour point rainflow counting matrixWave spectraJonswap spectrumPierson Moskowitz spectrumISSC spectrumGaussian Swell spectrumOchi-Hubble spectrumWind spectraDavenport spectrum with drag coefficientDavenport spectrum with roughness lengthEC1 spectrumIEC spectrumAPI spectrumSequence spectraPeriodogram spectrumWelch spectrumRandom and probabilistic modelMetropolis-Hastings algorithmMetropolis-Hastings samplerAu modified Metropolis-Hastings samplerNataf algorithmNataf transformationRisk and reliability modelFirst order second momentMean value FOSMFirst order reliability methodHasofer-Lind-Rackwitz-Fiessler FORMConstrained optimization FORMSecond order reliability methodBreitung SORMTvedt SORMHohenbichler and Rackwitz SORMSimulation based reliability methodSubset simulationUtilityAggregationCycle counting aggregationCounting matrixCounting results to counting matrixDerivativesDerivativeCentral derivative weightsGradientHessian matrixDigitizationSequence digitizationFitterSN curve fitterSequence filterSequence peakValley filterSequence hysteresis filterDocumentYou can find the latest documentation for setting upFFPACKat theRead the Docs site.CreditsThis project was made possible by the help fromDM2L lab.LicenseGPLv3
Package: ffpb
Not smart. Not comprehensive. Not guaranteed to work.ffpbis an FFmpeg progress formatter. It will attempt to display a nice
progress bar in the output, based on the rawffmpegoutput, as well as an
adaptative ETA timer.Showcase(yes, my laptop can’t encode shit)Usageffpbis is not even self-aware. Any argument given to theffpbcommand
is transparently given to theffmpegbinary on your system, without any form
of validation. So if you know how to use the FFmpeg CLI, you know how to useffpb!Using as a libraryffpbcan be used as a library: use theffpb.mainfunction:ffpb.main(argv=None,stream=sys.stderr,encoding=None,tqdm=tqdm):argvThe arguments to pass toffmpeg, as an argument list.streamThe stream to which to write the progress bar and the output messages.encodingThe encoding of the terminal, used to decode theffmpegoutput.
Defaults tolocale.getpreferredencoding(), orUTF-8is locales are
not available.tqdmThe progress bar factory to use. A subclass oftqdm.tqdmis expected.
Checkalthonos/ffpb#19to
see how you can use this to wrapffpbin your own UI.InstallationInstall from PyPI:$pipinstall--userffpbAlternatively, download a development version from the GitHubmasterbranch:$pipinstallhttps://github.com/althonos/ffpb/archive/master.zipOr if you use an Arch-based distro,download from the AUR
Package: ffpp
FlashForge 3D Printer ProtocolAsync python protocol for flashforge printers.
A simple way to connect and interact with your 3D printer.Tested on FlashForge Adventure 4, most likly to be working with other FlashForge printers.How to usefrom ffpp.Printer import Printer
myPrinter = Printer('192.168.0.1', 8899) # Change to the ip of your printer.
await myPrinter.connect()

print(f"{myPrinter.machine_type} is {myPrinter.machine_status}")Check out example to learn more.Important noteYou need to call theupdate()to get the current status, temperature and print percent from printer.await myPrinter.update()
print(myPrinter.print_percent)
await myPrinter.update()
print(myPrinter.print_percent)Information from 3D printerThis is the information collected from the printer.myPrinter.machine_typemyPrinter.machine_namemyPrinter.firmwaremyPrinter.machine_SNmyPrinter.maxXmyPrinter.maxYmyPrinter.maxZmyPrinter.extruder_countmyPrinter.mac_addressmyPrinter.machine_statusmyPrinter.move_modemyPrinter.statusmyPrinter.ledmyPrinter.current_filemyPrinter.print_percentTo get some temperature you need to get right tool.Run this line to return the extruder tool:extruder = myPrinter.extruder_tools.get()
# or by index
extruder2 = myPrinter.extruder_tools.get(1)You can do the same for your bed in myPrinter.bed_toolsThen you can do:extruder.now # Current temperature.
extruder.target # Target temperature.
Package: ffprb
Not smart. Not comprehensive. Not guaranteed to work.ffpbis an FFmpeg progress formatter. It will attempt to display a nice
progress bar in the output, based on the rawffmpegoutput, as well as an
adaptative ETA timer.Showcase(yes, my laptop can’t encode shit)Usageffpbis is not even self-aware. Any argument given to theffpbcommand
is transparently given to theffmpegbinary on your system, without any form
of validation. So if you know how to use the FFmpeg CLI, you know how to useffpb!Using as a libraryffpbcan be used as a library: use theffpb.mainfunction:ffpb.main(argv=None,stream=sys.stderr,encoding=None,tqdm=tqdm):argvThe arguments to pass toffmpeg, as an argument list.streamThe stream to which to write the progress bar and the output messages.encodingThe encoding of the terminal, used to decode theffmpegoutput.
Defaults tolocale.getpreferredencoding(), orUTF-8is locales are
not available.tqdmThe progress bar factory to use. A subclass oftqdm.tqdmis expected.
Checkalthonos/ffpb#19to
see how you can use this to wrapffpbin your own UI.InstallationInstall from PyPI:$pipinstall--userffpbAlternatively, download a development version from the GitHubmasterbranch:$pipinstallhttps://github.com/althonos/ffpb/archive/master.zipOr if you use an Arch-based distro,download from the AUR
Package: ffprobe3-esarjeant
A wrapper around ffprobe command to extract metadata from media files.This project which is maintained by Eric Sarjeant is a Python 3 port of original ffprobe3 which is itself a fork
of ffprobe.Home-page:https://github.com/esarjeant/ffprobe3Author: Simon Hargreaves
Author-email:simon@simon-hargreaves.comMaintainer: Eric Sarjeant
Maintainer-email:eric@sarjeant.usLicense: UNKNOWN
Description: UNKNOWN
Keywords: ffmpeg,ffprobe,mpeg,mp4
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Environment :: Console
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: MacOS :: MacOS X
Classifier: Operating System :: Microsoft :: Windows
Classifier: Operating System :: POSIX
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: Implementation :: CPython
Classifier: Natural Language :: English
Classifier: Topic :: Multimedia :: Video
Classifier: Topic :: Software Development :: Libraries
Package: ffprobe-python
ffprobe-python moduleA wrapper around the ffprobe command to extract metadata from media files.Usage::#!/usr/bin/env pythonfromffprobeimportFFProbemetadata=FFProbe('test-media-file.mov')forstreaminmetadata.streams:ifstream.is_video():print('Stream contains{}frames.'.format(stream.frames()))This software is now maintained by Mark Ma519329064@qq.com.(The MIT License)Copyright 2013 Simon Hargreavessimon@simon-hargreaves.comPermission 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.
Package: ffptutils
ffptutils-pyA python library that reads/writes Spirent iTest Parameter (.ffpt) files.Tested with Python 3.6, 3.7, and 3.8 on Windows and Ubuntu platforms.FeaturesConvert .ffpt file <-> .csv file.Supported CSV encoding is utf-8 with BOM (Suitable for Windows Excel).Supported Parameter Types are: TEXT, BOOLEAN, INTEGER and DOUBLE.Load .ffpt file from your python script.Installpip install ffptutilsUsage 1) Convert .ffpt <-> .csvConvert a ffpt file to csv format.> ffpt2csv file1_orig.ffpt edit.csvEdit the csv file using Excel or other software.Convert the csv file back to ffpt format.> csv2ffpt edit.csv file1.ffptUsage 2) General purpose .ffpt file loaderimportffptutilspt=ffptutils.load('test/2.ffpt')assertpt['param1']=='some value'assertpt['param2']==Trueassertpt['param3']==Falseassertpt['param4']==Noneassertpt['param5']==24assertpt['param6']==1.0assertpt['param7/param1']=='hoge'assertpt['param7/param2/param1']=='fuga'As you can see, it recognizes the Parameter types and converts into the appropriate python types as below:TEXT -> strDOUBLE -> floatINTEGER -> intBOOLEAN -> boolPIP Packagehttps://pypi.org/project/ffptutils/
Package: ffpyplayer
FFPyPlayer is a python binding for the FFmpeg library for playing and writing
media files.For more information:https://matham.github.io/ffpyplayer/index.htmlTo install:https://matham.github.io/ffpyplayer/installation.htmlWarningAlthough the ffpyplayer source code is licensed under the LGPL, the ffpyplayer wheels
for Windows and linux on PYPI are distributed under the GPL because the included FFmpeg binaries
were compiled with GPL options.If you want to use it under the LGPL you need to compile FFmpeg yourself with the correct options.Similarly, the wheels bundle openssl for online camera support. However, releases are not made
for every openssl release, so it is recommended that you compile ffpyplayer yourself if security
is a issue.Usage examplePlaying a file:>>>fromffpyplayer.playerimportMediaPlayer>>>importtime>>>player=MediaPlayer(filename)>>>val=''>>>whileval!='eof':...frame,val=player.get_frame()...ifval!='eof'andframeisnotNone:...img,t=frame...# display imgWriting a video file:>>>fromffpyplayer.writerimportMediaWriter>>>fromffpyplayer.picimportImage>>>w,h=640,480>>># write at 5 fps.>>>out_opts={'pix_fmt_in':'rgb24','width_in':w,'height_in':h,...'codec':'rawvideo','frame_rate':(5,1)}>>>writer=MediaWriter('output.avi',[out_opts])>>># Construct image>>>size=w*h*3>>>buf=bytearray([int(x*255/size)forxinrange(size)])>>>img=Image(plane_buffers=[buf],pix_fmt='rgb24',size=(w,h))>>>foriinrange(20):...writer.write_frame(img=img,pts=i/5.,stream=0)Converting images:>>>fromffpyplayer.picimportImage,SWScale>>>w,h=500,100>>>size=w*h*3>>>buf=bytearray([int(x*255/size)forxinrange(size)])>>>img=Image(plane_buffers=[buf],pix_fmt='rgb24',size=(w,h))>>>sws=SWScale(w,h,img.get_pixel_format(),ofmt='yuv420p')>>>img2=sws.scale(img)>>>img2.get_pixel_format()'yuv420p'>>>planes=img2.to_bytearray()>>>map(len,planes)[50000,12500,12500,0]
Package: ff-rem
Fourier-filtered Relative Entropy MinimizationImplementation of the Fourier-filtered Entropy Minimization (FF-REM) method for HOOMD-blue.
The method is described in detail in the associated publication:Carl S. Adorf, James Antonaglia, Julia Dshemuchadse, Sharon C. Glotzer, 2018. DOI:10.1063/1.5063802.Free software: MIT licenseDocumentation:https://ff-rem.readthedocs.io.QuickstartA complete example for the recovery of a Lennard-Jones potential is shown inexamples/lennard-jones.RequirementsnumpyHOOMD-bluegsdTestingTo execute unit tests, run:$python-munittestdiscovertests/within the package root directory.CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2018-10-17)First release on PyPI.
Package: ffscraper
Collaborative Filtering in FanFiction Networks"ffscraper" Yet another set of scraping tools for FanFiction.NetAlexander L. Hayes(@batflyer)Installationpip install ffscraperRequires:bs4,requestsBackgroundFanFiction.Net was established in 1998 and is among the world's largest collection of user-submitted fanfiction (works of fiction authored by fans of existing stories, such as movies, books, or TV shows). The large amount of easily-available user content has drawn interest from those interested in analyzing the content and creative differences between original works and their fanfiction derivatives [1]. More recently, [2] created an anonymized dataset of the metadata from fanfiction sources.This repository's purpose is twofold: creating robust open-source tools for scraping content, and using that content to build open-source systems which can be used by the FanFiction.Net community.References[1] Milli, Smitha and David Bamman, "Beyond Canonical Texts: A Computational Analysis of Fanfiction." Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing.[2] Yin, K., Aragon, C., Evans, S. and Katie Davis. "Where No One Has Gone Before: A Meta-Dataset of the World's Largest Fanfiction Repository." Proceedings of the 2017 CHI Conference on Human Factors in Computing Systems. ACM, 2017.AttributionThis was originally part of a final project for Professor Vibhav Gogate's Spring 2018Advanced Machine Learningclass at the University of Texas at Dallas. This version of the code, TeX, and .pdf are tagged as v0.1.0.monochromeis a Jekyll theme by@dyutibarma. Used under the terms of theMIT License.
Package: ffselect
ffselectFast feature subset selection libraryThis algorithm performs feature subset selection inO(n log n)orO(n)timeIt may be useful for eliminating polynomial features with n equal to hundreds or thousands, where regular subset selection algorithms cannot perform in adequate time.Usagefromffselect.subsetimportMinSubsetSelection,FastSubsetSelectionMinSubsetSelection(data,target,fit_function,features,loss=True,interactive=True)"""Minimal feature subset selection algorithmdata: Input data to pass to the fitting functiontarget: Target parameter feature namefit_function: Callable function that fits the model and returns R^2/lossfeatures: List of feature namesloss: Set to true (by default) if the fitting function returns loss, R^2 otherwiseinteractive: Print output (default True)return: Tuple with the resulting R^2/loss and the list of features"""defFastSubsetSelection(data,target,fit_function,features,threshold=None,loss=True,interactive=True):"""Fast feature subset selection algorithm in linear time. May drop important featuresdata: Input data to pass to the fitting functiontarget: Target parameter feature namefit_function: Callable function that fits the model and returns R^2/lossfeatures: List of feature namesthreshold: Minimal difference in loss/R^2 at which we drop the featureloss: Set to true (by default) if the fitting function returns loss, R^2 otherwiseinteractive: Print output (default True)return: Tuple with the resulting R^2/loss and the list of features"""Please viewsubset.ipynbfor the complete exampleInstallationpip3 install ffselect
Package: ffsend
Python client tohttps://send.firefox.com. Encrypts and decrypts on the fly to reduce memory usage.UsingPrerequisites:pipinstallffsendUsage is really simple:ffsend'https://send.firefox.com/download/abcdef0123/#keykeykey'# download a file to the current directoryffsendpath/to/file# upload a file to Firefox SendAdvanced usageSeveral commands take a-t/--tokenparameter, which is the "Owner token" displayed after a successful upload. If you uploaded the file with your browser, the owner token will be in the browser'slocalStorage.Getting file informationTo get basic information:ffsend-i'https://send.firefox.com/download/abcdef0123'To get more information (including number of times downloaded):ffsend-i-tTOKEN'https://send.firefox.com/download/abcdef0123'Deleting a fileffsend--delete-tTOKEN'https://send.firefox.com/download/abcdef0123'Updating file settingsffsend--set-dlimitN-tTOKEN'https://send.firefox.com/download/abcdef0123'LicenseCode is copyright Robert Xiao (nneonneo@gmail.com), and is licensed under the Mozilla Public License 2.0.
Package: ffsendclient
Firefox Send Client__.|.__
     .-"'..':`..`"-.
   .' .' .  :  . `. `.
  / .  FFSENDCLIENT . \
 /_ _._ _.._:_.._ _._ _\
   '   '    |    '   '
            |
            |
            |
         \  |  /
          \ | /
           \ /
            'Firefox Send API Clientffsendclient is a library for interfacing with Firefox Sendhttps://send.firefox.com/or your own instance of it.Install➜ pipenv install ffsendclient
➜ # ...or...
➜ pip3 install ffsendclientUsageBasic file upload...>>> import os
>>> from ffsendclient import SendClient
>>> send = SendClient('send.firefox.com')
>>> up_data = os.urandom(1024)
>>> fid, owner_token, url = send.upload('ffsendclient.bin', up_data)
>>> fid
'eb99746752a74975'
>>> owner_token
'fc8a7a910688869021be'
>>> url
'https://send.firefox.com/download/eb99746752a74975/#xsKqVUcdh_Dp6GDn2zUVLg'... and continue to download:>>> secret = url.split('#')[1]
>>> secret
'xsKqVUcdh_Dp6GDn2zUVLg'
>>> file_name, down_data = send.download(fid, secret)
>>> file_name
'ffsendclient.bin'
>>> up_data == down_data
TruePasswords, download limits and time limits are also supported. Full
documentation is athttps://gitlab.com/skorov/ffsendclient.SupportedPython 3.6+Firefox Send v3.0.21+Not yet supportedMulti-file upload/downloadFirefox authentication:copyright: (c) 2019 by Alexei Doudkine.
:license: Apache 2.0, see LICENSE for more details.
Package: ffsim
ffsimFaster simulations of fermionic quantum circuits.What is ffsim?ffsim is a software library for simulating fermionic quantum circuits that conserve particle number
and the Z component of spin. This category includes many quantum circuits used for quantum chemistry simulations.
By exploiting the symmetries and using specialized algorithms, ffsim can simulate these circuits much faster
than a generic quantum circuit simulator.Experimental disclaimer: ffsim is currently an experimental release. Breaking changes may be introduced without warning.DocumentationDocumentation is located at theproject website.Supported platformsffsim is supported on Linux, macOS, and the Windows Subsystem for Linux (WSL). It is not supported on Windows.InstallationFrom PyPIffsim is available onPyPI. It can be installed by running the commandpipinstallffsimFrom sourceInstalling ffsim from source requires the following system dependencies:A Rust compiler. Seethese instructions.A BLAS implementation.On macOS, ffsim uses theAccelerateframework that is included with the operating system, so no action is required.On Linux, ffsim usesOpenBLAS. You may be able to install it using your system package manager:Arch Linux:sudopacman-Sblas-openblasFedora:sudodnfinstallopenblas-develUbuntu:sudoaptinstalllibopenblas-devOnce these dependencies are satisfied, ffsim can be installed by running the commandpipinstall.from the root directory of the code repository.DevelopmentTo set up ffsim for development, install it from source in editable mode along with the development requirements:pipinstall-e".[dev]"If you add or modify any Rust modules, rebuild them by running the commandmaturindevelopIf you are benchmarking the code, then pass the--releaseflag:maturindevelop--releaseTests and other code checks are managed usingtox.
To run the default tox environments, simply runtoxTo run a specific environment, for example, to run the lint checks, dotoxrun-elintYou can also usepytestto run the tests directly. For example,pytesttests/Cite ffsimYou can cite ffsim using the following BibTeX:@software{ffsim,author={{The ffsim developers}},title={ffsim},url={https://github.com/qiskit-community/ffsim}}
Package: ffsize
f(ile)f(older)sizePython script to quickly check the size and optionally crc of all files and folders in a directory and its contents recursively. Also includes a status bar and can export a list of contents with size and crc as a csv.Prints:file countfolder counttotal file sizetotal file + folder sizetotal crc for all data (with--crc)[any file/folder read/access errors]Get from PyPI:https://pypi.org/project/ffsize/usage: ffsize [options] path

Counts all the files, folders, total sizes, and optionally crc in the directory
recursively.

positional arguments:
  path

optional arguments:
  -h, --help      show this help message and exit
  -v, --version   show program's version number and exit
  -c, --crc       take checksum (CRC32) of files
  -s, --sym       follow symbolic links that resolve to directories
  -w, --csv       write list of files, folders, and info to ffsize.csv
  --enc encoding  set csv encoding, see
                  https://docs.python.org/3/library/codecs.html#standard-encodings
Package: ffsuspend
FFSuspendA small script to monitor processes and i3 events in order toSIGSTOPGUI
processes when their X windows are not on a visible i3 workspace.But WHY?!I'm travelling a lot by train and use that time to work on stuff on my laptop.
I tend to keep open some programs, like a browser with some documentation or
library reference. However some programs, after being used for a while, tend to
consume up to one CPU core just for idling (looking at you, firefox), which
significantly lowers battery life and brings me in the uncomfortable situation
to have a constantly warm computer on my lap. So instead of tackling the root
cause, I went for the easiest route and this script is the result of that.DependenciesThis is a hacky script that defers much of its functions by parsing the output
of some utility programs. These need to be installed for it to work:i3-msgkillallpsxdotoolxselCaveats / DisclaimerThe X clipboard protocol is an IPC protocol that talks to the current owner of
the clipboard, whenever its contents is requested. If this process isSIGSTOPed, applications tend to freeze indefinitely, whenever trying to read
the clipboard contents.While there is probably a cleaner solution, FFSuspend has a hacky feature that
monitors clipboard contents and skips one cycle of stopping a process, when the
clipboard was changed while that process' window was visible. This can be
enabled with the-ccommandline flag.There may be other 'interesting' sideeffects whenSIGSTOPing processes, so be
wary and use at your own risk.LicenseFFSuspend is licensed under the GPLv3 or later, seeLICENSE.txt.