Saravanan666/pypi-org huggingface dataset:
Package: ffg
fusion-function-generator (ffg)Automatic generation ofFusion Functionsused byyinyangfuzzer forSemantic Fusion.Lib structureThe package is divided into 4 folders:genoperatorsvisitorsemitterThe foldergencontains the code which is used to generate the wholeoperatorsfolder, theconfiguration fileexposing some api to control which operators to use during the generation of the tree as well as some constants for the options to the generation algorithm.
the filetree_generationinstead contains the main tree generation algorithm.operatorscontains the basic definition of the operators classes.visitorsfolder contains useful api to print, export to DOT format and rewrite the trees to their inverses.Finally,emitterincludes the code needed to export fusion functions to the format understood by YinYang. It also contains an emitter that outputs fusion functions and its inverses to DOT file.CookbookUse only a subset of the theories in the generation:ffg.gen.gen_configuration.set_available_theories(['bool','real'])Get the available theories:ffg.gen.gen_configuration.get_theories()Generate a fusion function of two variables (as a tree):tree,_=ffg.gen.tree_generation.generate_tree(root_type,size,['x','y'],'z')Emit the fusion function to YinYang format as a string:output=io.StringIO()emit_function(tree,output,wrap=False)ff=output.getvalue()
Package: ffiec-data-connect
FFIEC Data ConnectorThe FFIEC Webservice Python Connector library (ffiec_data_connect) downloads data from the FFIEC (Federal Financial Institution Examination Council) via the FFIEC's "webservice" interface.The library interfaces with the SOAP-based API published by FFIEC, normalizing dates and data, conducting transformations to permit immediate analysis of acquired data within a Python data science or scripted environment.DisclaimerThis package and documentation is not affiliated with the Federal Financial Institution Examination Council (FFIEC) or any other US Government Agency.Please review the license and disclaimer before using this package.OverviewThe FFIEC Webservice Python Connector (ffiec_data_connect) was created to facilitate the use of the SOAP-based FFIEC Webservice.Although limited documentation is provided for the Webservice by the FFIEC, practical use of the Webservice via Python requires a considerable amount of boilerplate code - and knowledge of esoteric terms and concepts inherent to bank regulatory data.With these challenges in mind, this package provides a Python wrapper for the FFIEC Webservice, simplifying the process of interacting with the Webservice, and allow the rapid development of Python applications that require use of the data hosted on the Webservice.Data returned from the Webservice may be returned as a native Python data structure (list) or Pandas DataFrames or Series.Installationpip install ffiec-data-connectQuickstartTo run this Quick Start, you must have an account on the FFIEC Webservice athttps://cdr.ffiec.gov/public/PWS/CreateAccount.aspx?PWS=trueAfter you create an account, verify your password, and complete the sign-in process, log into the public web interface here:https://cdr.ffiec.gov/Public/PWS/Login.aspxWhen you login, go to the "Account Details" tab. On this screen, look for theSecurity Token. This token is the password that you will use for the login credentials for ffiec-data-connect,not the password.Sample code to login and collect reporting periods:from ffiec_data_connect import methods, credentials, ffiec_connection
        
        creds = credentials.WebserviceCredentials(username="USER_NAME_GOES_HERE", password="SECURITY_TOKEN_GOES_HERE")

        conn = ffiec_connection.FFIECConnection()

        reporting_periods = methods.collect_reporting_periods(
            session=conn,
            creds=creds,
            output_type="list",
            date_output_format="string_original"
        )
Package: ffio
FFio: Fast and flexible video IO toolbox for Pythontest descriptionFree software: MIT licenseDocumentation:https://ffio.readthedocs.io.FeaturesTODOCreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2020-04-08)First release on PyPI.
Package: ffire
Ffire enables you to use GUI Style event driven programming in your web application with
10 lines of code or less.ffire can be summed up by its simple API.InstallationpipinstallffireCreating and Firing Events#: Order Creation API/Engine : Application One (France or Germany or Mars)fromffireimportfire#: Create is idempotent. You can call create multiple times without side effects#: in addition it is more advisable to use constants i.e. ORDER_CREATED not literalsffire.create('order_created',category='event')#: Do application logic herepayload={"order_id":"abcd","client_id":"1234"}ffire('order_created',payload)#: ORffire.fire('order_created',payload)Subscribing to events# # Biryani Client : Application Two in (Brazil, South Africa or Venus)fromffireimportfireendpoint='http://api.example.com/order-created-handler'fire.subscribe('order_created',endpoint)#: Ffire assumes a handler for the payload sits at that endpoint.It is advisable to have a message broker as the endpoint. However this is not mandatory especially for cases where handling the event is not an absolute necessity.In such scenarios any endpoint is sufficient.Consume EventsIf you wish to consume events from ffire explicitly you can do so.fromffireimportffirefire.consume('order_created',ffire.TIME_INTERVALS.ONE_HOUR)
Package: ffl
Forcast Federated LearningForcast Federated Learning (FFL) is an open-sourcePytorchbased framework for machine learning on decentralized data. FFL has been developed to facilitate open experimentation withFederated Learning (FL), an approach to machine learning where a shared global model is trained across
many participating clients that keep their training data locally. For example,
FL has been used to trainprediction models for mobile keyboardswithout uploading sensitive typing data to servers.FFL enables developers to use low level model aggregation into a federated model. Explicitly using individual data per client and sharing only the local models or model gradients. This helps bridge the gap from simulation, into simulation with isolated clients and private data and onto deployment.InstallationSee theinstalldocumentation for instructions on how to
install FFL as a package or build FFL from
source.Getting StartedSee theget starteddocumentation for instructions on
how to use FFL.
Package: fflocker
FFLockerLocking files/folders [FF] in GNU/Linux via text-based user interface (TUI).The most important part of the algorithm is that during the locking process, your password is never saved on the computer and only displayed in the terminal for you to save it.DescriptionFFLocker uses AES encryption. You can either create a password with 16, 24, and 32 characters (which corresponds to 128, 192, and 256 bits, respectively) or generate a random password with the help of thesecrets.choice.After you lock the file/folder, the program will change the binary data and overwrite it. To read/open the encrypted file/folder, you have to enter the password.I have written the program in such a way that when you decrypt the file/folder, a new file/folder will be created as a precaution against entering the wrong password. At the end of the decryption process, you can permanently delete the encrypted file/folder via a single command (see theWARNINGsubsection).Additionally, every file and folder receives.encandENCextensions at the end of the encryption process. If your pathname does not contain these extensions, the decryption process does not begin. Similarly, you cannot encrypt the file/folder if it has a.encorENCextension.WARNINGEven if your password is wrong, the program will decrypt the file/folder and produce a resultif it has a sufficient number of characters (bytes). In this case, be careful about deleting the encrypted file/folder since the decrypted one will be unreadable due to the wrong password. As for advice, always open and read the decrypted file/folder before you delete the encrypted one.InstallationYou can install the FFLocker viapippython3 -m pip install fflockeror by directly cloning to your desired directorygit clone https://github.com/camarman/FFLocker.gitRequirementsFFLocker requirespycryptodome, which can be installed by runningpython3 -m pip install pycryptodomeUser GuideTo start thefile lockingprocess runpython3 -m fflocker.file_lockerSimilarly, to start thefolder lockingprocess runpython3 -m fflocker.folder_lockerfrom the terminal.OverviewEncryption process of a fileDecryption process of a fileEncryption process of a folderDecryption process of a folderUpcoming FeaturesI am thinking to implement a command line interface (CLI), and it will probably look like this:$ fflocker -Fe [path]
$ fflocker -De [path]
$ fflocker -Fd [path]
$ fflocker -Dd [path]

-F --File
-D --Directory
-e --encrypt
-d --decrypt
Package: fflows
Fourier-flows 🌀Code for theGenerative Time-series Modeling with Fourier Flowspaper.Code author: Ahmed AlaaDescriptionGenerating synthetic time-series data is crucial in various application domains, such as medical prognosis, wherein research is hamstrung by the lack of access to data due to concerns over privacy.Most of the recently proposed methods for generating synthetic time-series rely on implicit likelihood modeling using generative adversarial networks (GANs)—but such models can be difficult to train, and may jeopardize privacy by “memorizing” temporal patterns in training data.In this paper, we propose an explicit likelihood model based on a novel class of normalizing flows that view time-series data in the frequency-domain rather than the time-domain. The proposed flow, dubbed aFourier flow, uses a discrete Fourier transform (DFT) to convert variable-length time-series with arbitrary sampling periods into fixed-length spectral representations, then applies a (data-dependent) spectral filter to the frequency-transformed time-series. We show that, by virtue of the DFT analytic properties, the Jacobian determinants and inverse mapping for the Fourier flow can be computed efficiently in linearithmic time, without imposing explicit structural constraints as in existing flows such as NICE (Dinh et al. (2014)), RealNVP (Dinh et al. (2016)) and GLOW (Kingma & Dhariwal (2018)).InstallationInstall withpip:pipinstallfflowsExamplesFit a Fourier flowimportnumpyasnpfromfflowsimportFourierFlowT=11n_samples=100dims=3X=np.random.randn(n_samples,T,dims)model_params={"hidden":11,"n_flows":11,}train_params={"epochs":10,"batch_size":500,"learning_rate":1e-3,"display_step":100,}model=FourierFlow(**model_params)model.fit(X,**train_params)Generate new datasamples=model.sample(10)assertsamples.shape==(10,T,dims)DataThe public datasets used in the paper are available at:https://drive.google.com/drive/folders/1UILaMFnZpRUf_IhOIkxK2wzBjWBTB86GExperimentsFor Experiment 1 (Section 5.1), runICLR 2021 - Experiment 1.ipynb.For Experiment 2 (Section 5.2), runrun_experiment_2.py.CitingPlease cite using:@inproceedings{alaa2020generative,title={Generative Time-series Modeling with Fourier Flows},author={Alaa, Ahmed and Chan, Alex James and van der Schaar, Mihaela},booktitle={International Conference on Learning Representations},year={2021}}
Package: ffm3u8
二代的ffm3u8模块修改了第一代一些问题并提供了IV的写入使模块的使用更加多元化，当然相比于第一代第二代也并没有太多的改变，模块的使用还是有太多的限制，不过我还会继续更新的，希望大家喜欢！安装方式：pip install ffm3u8使用方法：解密方法：ffm3u8.get_url_key(name='m3u8的路径', name2='ts的前域名', op='保存的路径（使用/后面需要加上/如：D:/xuexipan/python/crawler/视频/新建文件夹/）', headers=请求头, key_url='密钥的url', IV='填入IV没有则填入16个0')不解密的方法：ffm3u8.get_aio_url(name='m3u8的路径', name2='ts的前域名', op='保存的路径（使用/后面需要加上/如：D:/xuexipan/python/crawler/视频/新建文件夹/）', headers=请求头)联系电话：181 2874 4689（微信，QQ同号）（备注来因）邮箱：13360350080@163.com希望大家可以多多留意，多多提建议！感谢@企鹅诶i提供的技术支持！感谢re, aiohttp, asyncio, aiofiles, AES, Crypto模块提供的模块支持非常感谢！告示：任何人使用本模块做的违规违法，及任何的利益纠纷的产生的责任，模块制作所有人概不负责
Package: ffmaxflow
This package implements the Fork Fulkerson algorithm to find the maximum posible flow in a network.The Ford-Fulkerson method answers the question of given a network with vertices and edges between those vertices that have certain weights, how much “flow” can the network process at a time?Change Log0.0.1 (17/03/21)First release0.0.2 (18/03/21)Name change0.0.3 (18/03/21)Better docstrings0.0.4 (27/03/21)Trying out the long description0.0.5 (21/04/21)Reimplementations and reinforcement0.0.6 (24/04/21)Change in warning for loops0.0.7 (26/04/21)Prints warnings instead of returning them.0.0.8 (27/04/21)Adds self-explanatory messages in loop errors.0.0.9 (27/04/21)Change in warning messages for repeated sink and source nodes.
Package: ffmigration
ffmigrationstands for “fast forward migration” and is a simple database
migration program.Is a simple ans elegant way of keeping database migrations in order in
various environemnts, keeping track of wich database migratison are
executed and with none.ffmigrationis a forward only migration tool, it means that there isnt
ant automatic way to rollback and applied migration.How it worksffmigrationcreates a table namesmigration_historyon the
selected database to keep track od the applied migrations. This table is
created automatically on first run.On every run,ffmigrationlooks to all the files with a .sql extension
in the migration directory provided in the command line, checks if the
migration file has been applied to the database, and if ih has not been aplied
it is apllied to the the database and saved tomigration_history.It is recomended to name all the migration files prefixed with a number
to keep the order. For example:$ ls /some/migrations/dir/
0001_create_some_table.sql
0002_add_some_data.sql
0003_create_index.sql
0004_other_useful_tweaks.sqlLimitationsThis is a beta software with some limitations:By now it only works with MySQL.InstallingUsesetup.py:python setup.py build
sudo python setup.py installor usepip:pip install ffmigrateCommand line$ ./ffmigration --help
Usage: ffmigration [options] database migrations_dir

Apply database migrations from migrations_dir to selected database.
migration_dir contains files with .sql extension, that are sorted
and applied.

The applied migrations are saved on a table named  'migration_history'
in the selected database

Options:
  --version             show program's version number and exit
  -h, --help            show this help message and exit
  -H HOST, --host=HOST  Database server hostname
  -u USER, --user=USER  database username
  -p                    ask for a database password
  --password=PASSWORD   database password
  -P PORT, --port=PORT  database connection port
  -q, --quiet           don't print status messages to stdout
  -l LEVEL, --level=LEVEL
                        logging level (debug,info,warning,error,critical)
  -n, --noop            Do not run commands.
Package: ffmirror
ffmirror is a program to create and maintain a local mirror of stories on
fiction-publishing sites. It has functionality for downloading stories similar
to FanFicFare or other projects, but the differentiating factor is support for
creating a local database that maintains downloaded metadata and can
automatically update authors that are followed.ffmirror has two currently maintained script entry points:ffdl is a simple one-story file downloader. It takes a single URL and writes
an HTML file story.ffdb is the manager for local fanfic site mirrors. These maintain a local
copy of metadata for a set of followed users alongside copies of all their
stories.The remaining entry points, ffadd, ffup, ffcache are designed for an older
format of mirror, and are now deprecated.ffmirror can be installed via PyPI:pip install ffmirrorTo create a mirror, enter an empty directory and issue:$ffdbinitThis initializes the SQLite database that tracks metadata. You can now add
authors by issuing:$ffdbadd$AUTHOR_URLAdding an author will immediately download all their stories into the mirror.
Stories are stored under top-level directories per author.Updating the mirror will recheck all authors that have been added and download
any new or updated stories. To update the mirror, issue:$ffdbupdateYou can update only one author by issuing:$ffdbupdate$AUTHOR_DIRwhere AUTHOR_DIR is the directory with that author’s stories.
Package: ffmpegaudiorecord
Starts recording audio from the specified device using ffmpeg and stops recording after a specified number of seconds of silencepip install ffmpegaudiorecordTested against Windows 10 / Python 3.10 / AnacondaThefunctionfirstcheckstoseeiftheffmpegexepathisinthesystempath.Ifnot,itaddsthepathtothesystempath.Next,thefunctiongetsthelistofavailableaudiodevicesusingtheget_all_devicesfunctionfromtheffmpegdevicesmodule.Itthentriestofindtheaudiodevicethatmatchestheaudiodeviceargument.Ifnomatchisfound,thefunctionraisesanexception.Thefunctionthenstartsanewffmpegprocesstorecordaudiofromthespecifieddevice.Itcreatesatemporaryfiletostoretherecordedaudio.Thefunctionthenentersaloopthatreadstherecordedaudiofromthetemporaryfileandchecksforsilence.Iftheaudioissilentforaspecifiednumberofseconds,thefunctionstopsrecordingandreturnstherecordedaudioasanAudioSegmentobject.Anysilenceatthebeginningisignored.Args:ffmpegexe:Thepathtotheffmpegexecutable.audiodevice:TheIDornameoftheaudiodevicetorecordfrom.silent_seconds_stop:Thenumberofsecondsofsilenceafterwhichrecordingwillstop.silence_threshold:Theaudiolevelbelowwhichsilenceisconsideredtohaveoccurred.Returns:TherecordedaudioasanAudioSegmentobject.fromffmpegaudiorecordimportstart_recordingaudio_data=start_recording(ffmpegexe=r"C:\ffmpeg\ffmpeg.exe",audiodevice=1,silent_seconds_stop=3,silence_threshold=-30)audio_data.export("c:\\bababababa.wav")
Package: ffmpeg-auto-settings
ffmpeg-auto-settingsToolkit for finding optimal libx26{4,5} quality-based settings.LinksGitLab repositoryDocumentationPyPILicenseffmpeg-auto-settings is free software: you can redistribute it and/or modify it under the terms of the
GNU General Public License Version 3 as published by the Free Software Foundation.ffmpeg-auto-settings 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 ffmpeg-auto-settings. If not, seehttps://www.gnu.org/licenses/.NB: Contrary to what GitLab might automatically display in its interface, later versions of the GPL donotapply to
this program.
Package: ffmpeg-binaries
ffmpeg for PythonStatic builds of ffmpeg for PythonInstallationFrom pip:pip install ffmpeg-binariesBasic usageimportffmpeg# Initialize module (only if no binaries found)ffmpeg.init()# Call ffmpeg directlyffmpeg.run_as_ffmpeg("-h")# Use the binaries path in other modulesother_module.add_ffmpeg(ffmpeg.FFMPEG_PATH)# Add directly to pathffmpeg.add_to_path()
Package: ffmpeg-gpt
ffmpeg_gptUsing GPT to generate bash scripts that use ffmpeg commands to process videos.InstallationFrompypipipinstallffmpeg_gptFrom sourcegitclonehttps://github.com/apirrone/ffmpeg_gptcdffmpeg_gpt
pipinstall.Set yout openai api key as an environment variable (put it in your .bashrc or equivalent for convenience)exportOPENAI_API_KEY=<your_api_key>Usage examples$ffmpeg-gpt"flip the video input.mp4 vertically, and export all its frames in a directory named out"Generatedscript:===========#!/bin/bashmkdirout
ffmpeg-iinput.mp4-vf"vflip"-q:v1out/frame%04d.jpg===========Doyouwanttorunthisscript?([Y]/n):
Package: ffmpeg-gui
FFMPEG-GUISimple TKinter GUI tool written in Python to facilitate some basic audio and video manipulations using ffmpegInstallationThe tool can be run on Linux, MacOS and Windows provided the following requirements are metRequirementsPython 3.7or abovepython3-tk (Comes with Python 3, but may need installing seperately in linux usingapt-get install python3-tk)To check what version of python is installed, open a console and run:python--versionIf the python version is suitable then run the following to install the image-sorting-toolpipinstallffmpeg-guiUsageTo launch the program after installation, run:ffmpeg-gui
Package: ffmpeg-input
FFmpeg Source Input LibraryFFmpeg Input Library is a small library aimed at receiving raw or decoded (RGB) frames from FFmpeg into a python program.
You can pass to ffmpeg required arguments and url and get the frames like opencv does. The library
provides the direct access to the ffmpeg library without the launching of the ffmpeg binary.
The frames are in raw binary format and must be processed separately.Install Prebuilt Wheelspipinstallffmpeg-inputBuild In Docker (Manylinux_2_28)# certain python version (decreases build time)#dockerbuild-tffmpeg_input-fdocker/Dockerfile.manylinux_2_28_X64--build-argPYTHON_INTERPRETER=/opt/python/cp38-cp38/bin/python.# all manylinux versions#dockerbuild-tffmpeg_input-fdocker/Dockerfile.manylinux_2_28_X64.# copy wheels from docker#dockerrun--rm-it-v$(pwd)/distfiles:/tmpffmpeg_inputcp-R/opt/dist/tmpTry ItRUST_LOG=debug python3 test.py
Package: ffmpegio-plugin-downloader
ffmpegio-plugin-downloader: Anffmpegioplugin to download latest FFmpeg release binariesPython ffmpegiopackage aims to bring
the full capability ofFFmpegto read, write, and manipulate multimedia
data to Python. FFmpeg is an open-source cross-platform multimedia framework, which can handle
most of the multimedia formats available today.One caveat of FFmpeg is that there is no official program installer for Windows and MacOS (althoughhomebrewcould be used for the latter).ffmpegio-plugin-downloaderadds a capability to download
the latest release build of FFmpeg and enables theffmpegiopackage to detect the paths offfmpegandffprobeautomatically. This mechanism is supported byffmpeg-downloaderpackage. Downloading of the release build must be performed interactively from the terminal screen,
outside of Python.UseInstall the package (which also installsffmpeg-downloaderpackage). Then, runffmpeg_downloaderto
download and install the latest release:pipinstallffmpegio-coreffmpegio-plugin-downloaderpython-mffmpeg_downloader# downloads and installs the latest releaseOnce the plugin and the FFmpeg executables are installed,ffmpegiowill automatically
detect the downloaded executables.At a later date, the installed FFmpeg can be updated to the latest releasepython-mffmpeg_downloader-U# downloads and updates to the latest releaseNoteffmpegio-plugin-downloaderwillnotbe activated ifffmpegandffprobeare
already available on the system PATH.
Package: ffmpegio-plugin-mpl
This plugin enables Pythonffmpegiopackage to output matplotlib’s Figure.InstallationTo enable it, install along withffmpegio-coreorffmpegiopackage:pipinstallffmpegio-core# or ffmpegio if also performing media I/Opipinstallffmpegio-plugin-mplThe plugin will be automatically loaded wheneverffmpegiopackage is imported.ExampleCreate an MP4 video ofMatplotlib’s animation example.importffmpegiofrommatplotlibimportpyplotaspltimportnumpyasnpfig,ax=plt.subplots()x=np.arange(0,2*np.pi,0.01)line,=ax.plot(x,np.sin(x))interval=20# delay in millisecondssave_count=50# number of framesdefanimate(i):line.set_ydata(np.sin(x+i/50))# update the data.returnlinewithffmpegio.open("output.mp4",# output file name"wv",# open file in write-video mode1e3/interval,# framerate in frames/secondpix_fmt="yuv420p",# specify the pixel format (default is yuv444p))asf:forninrange(save_count):animate(n)# update figuref.write(fig)# write new frame