Saravanan666/pypi-org huggingface dataset:
Package: fft-conv-pytorch
fft-conv-pytorchImplementation of 1D, 2D, and 3D FFT convolutions in PyTorch.Faster than direct convolution for large kernels.Much slowerthan direct convolution for small kernels.In my local tests, FFT convolution is faster when the kernel has >100 or so elements.Dependent on machine and PyTorch version.Also see benchmarks below.InstallUsingpip:pipinstallfft-conv-pytorchFrom source:gitclonehttps://github.com/fkodom/fft-conv-pytorch.gitcdfft-conv-pytorch
pipinstall.Example Usageimporttorchfromfft_conv_pytorchimportfft_conv,FFTConv1d# Create dummy data.#     Data shape: (batch, channels, length)#     Kernel shape: (out_channels, in_channels, kernel_size)#     Bias shape: (out channels, )# For ordinary 1D convolution, simply set batch=1.signal=torch.randn(3,3,1024*1024)kernel=torch.randn(2,3,128)bias=torch.randn(2)# Functional execution.  (Easiest for generic use cases.)out=fft_conv(signal,kernel,bias=bias)# Object-oriented execution.  (Requires some extra work, since the# defined classes were designed for use in neural networks.)fft_conv=FFTConv1d(3,2,128,bias=True)fft_conv.weight=torch.nn.Parameter(kernel)fft_conv.bias=torch.nn.Parameter(bias)out=fft_conv(signal)BenchmarksBenchmarking FFT convolution against the direct convolution from PyTorch in 1D, 2D,
and 3D. The exact times are heavily dependent on your local machine, but relative
scaling with kernel size is always the same.DimensionsInput SizeInput ChannelsOutput ChannelsBiasPaddingStrideDilation1(4096)44True0112(512, 512)44True0113(64, 64, 64)44True011
Package: fftl
fftl— generalised FFTLog for PythonThefftlpackage for Python contains a routine to calculate integral
transforms of the typeã(k) = ∫ a(r) T(kr) drfor arbitrary kernelsT.  It
uses a modified FFTLog [2] method of Hamilton [1] to efficiently compute the
transform on logarithmic input and output grids.Besides the generalised FFTLog algorithm, the package also provides a number of
standard integral transforms.InstallationInstall with pip:pip install fftlFor development, it is recommended to clone the GitHub repository, and perform
an editable pip installation.The core package only requiresnumpy.  The standard integral transform module
additionally requiresscipy.UsageThe core functionality of the package is provided by thefftlmodule.  Thefftl()routine computes the generalised FFTLog integral transform for a
given kernel.For convenience, a number of standard integral transforms are implemented in
thefftl.transformsmodule.User manualCore Functionality (fftl)Standard Integral Transforms (fftl.transforms)ReferencesHamilton A. J. S., 2000, MNRAS, 312, 257 (astro-ph/9905191)Talman J. D., 1978, J. Comp. Phys., 29, 35
Package: fft-multiplication
FFT MultiplicationAuthor:Moin KhanFFT Multiplication: An implementation of the Fast Fourier Transform (FFT) algorithm to multiply two polynomials efficiently.IntroductionFFT Multiplicationis a simple, zero-configuration command-line static HTTP server.Installation:Globally viapippip install fft_multiplicationThis will installfft_multiplicationglobally so that it can be imported into any python program.Usage:fromfft_multiplicationimportmultiplyp=[1,1]q=[1,0]print(multiply(p,q))FeaturesEfficient polynomial multiplication using the Fast Fourier Transform (FFT) algorithmComparison with the direct multiplication methodTest cases to ensure correctness of the implementationsRequirementsPython 3.xContributingAll contributions are welcome. Please create an issue first for any feature request
or bug. Then fork the repository, create a branch and make any changes to fix the bug
or add the feature and create a pull request. That's it!
Thanks!Licensefft_multiplicationis released under the MIT License.
Check out the full licensehere.
Package: fftpower23
fftpower23 package contains library to calculate Fast Foutrier Transformation.
Also it provides a set of functions to calculate commonly used sprectral characteristics (both single and mutual) for numerical series.The main difference from the other simular packages that it provides FFT for the series those have length based both powers 2 and 3.
The exact formula for acceptable lenghts is 4*2**n*3**m; n,m >= 0.
Any particular length can be checked by calling function IsValidLength (lenght)
List of first 100 allowed numbers (number №100 = 373248) can be found in docs/first_100_allowed_lengths.txtThe source code successfully compiled and tested on both python 2.7.6 and python 3.4.3
Original algoryth has been rewritten to python from C++, C++ source code is available athttps://bitbucket.org/VladimirPopov43/fft_cpp/srcFull public API with the example of usage can be found at docs/api_doc.txtSincerely yours,
Vladimir Popov,vladimir.popov@gmx.com
Package: ffuflags
ffuflags (formerly parse_ffuf)A way to generate filter flags forffuffrom a previous fuzz + more to come!MotivationTypically, anffufuser will use the-acautocalibration flag in order to automatically apply filters based off of initial tests ffuf will do before beginning a full fuzz.However, in my experience, I have found that the initial autocalibration ends up missing a lot of values that could be filtered-out.Manually-writing filter flags has been time-consuming, but I realized that I could automate the process with my current (and possibly overall) favorite programming language: Python!What this does is generate a string representing flags that are to be passed toffuf.I have a fuzzing script to help manage configuration options that I regularly pass intoffuf, so as an example in a script, you could do something like this:ffuf -X GET -w $WORDLIST0 $FLAGS -u "$1/FUZZ" $HEADERS -o $OUTFILE_SMALL;
FILTER=$(python3 -m ffuflags -i "$OUTFILE_SMALL");
ffuf -X GET -w $WORDLIST1 $FLAGS $FILTER -u "$1/FUZZ" $HEADERS -o $OUTFILE_BIG;Usagepython3 -m ffuflags -v -i <input_file> [-s | -p | -c <status_code>]
python3 -m ffuflags --verbose --input <input_file> [--sort-by-value | --sort-by-param | --code <status_code>]ExampleSimple Usagepython3 -m ffuflags -i myfuzz.jsonFiltering status codes from which flags you generatepython3 -m ffuflags -i myfuzz.json -c 200
python3 -m ffuflags -i myfuzz.json --code 200
python3 -m ffuflags -i myfuzz.json -c 200,404
python3 -m ffuflags -i myfuzz.json --code 200,404Print Extra Table of Results by Category (status code, length, duration, words, lines)python3 -m ffuflags -v -i myfuzz.json 
python3 -m ffuflags --verbose -i myfuzz.jsonSorting the Extra Table of Resultspython3 -m ffuflags -v -s -i myfuzz.json 
python3 -m ffuflags -v --sort-by-value -i myfuzz.json 
python3 -m ffuflags -v --sort-by-param -i myfuzz.jsonDid you find this tool helpful?Please consider sending me crypto through one of these addresses:Bitcoin: 38p6p4gLqfvZ4LShmWpNnphN1TjB8WgT8M
Litecoin: MU8YSVUVwKDiaQfPurW8cVzxjbeZc2qv2S
Ethereum: 0xC8E4ac8ee54698dDf47d7343e12aB83985F3900A
Monero: 87eZsjdCFHtQXEf4A2Mer1XjJmLmD6N1b2maovAR4XtSYs4EupxZB7UfmG9eyb8qXpVvR9HdsEpf7K3A762w3LcNTg1fLTCOr, you can become a patron on myPatreon page!I stream regularly on Twitch as well at:https://www.twitch.tv/darkmage666
Package: ffx-customization-tool
FFX Customization ToolIntroductionThe aim of this tool is make easier to find the source of material to add a
customization into a Weapon or Armor in Final Fantasy X.For administratorsPlease, readadministrator manual. There you can find
instructions about how to install, configure and uninstall this tool.For usersPlease, readuser manual. There you can find instructions about
how to use this tool.For developersPlease, readdeveloper manual. There you can find
instructions about how to develop this tool.ReferencesThere are some sources what I have to read to get data, so credit for the
authors too. See details intoreferences
Package: ffxivscraper
# FFXIV Lodestone Scraper## Install```# Linux global installsudo python setup.py install```## Lodestoner (cli tool)```LodestonerUsage:lodestoner char (<lodestone_id> | <server_name> <first_name> <last_name>)lodestoner free_company <lodestone_id>lodestoner verify <server_name> <first_name> <last_name> <key>lodestoner validate <server_name> <first_name> <last_name>lodestoner topics```## Authors- Stanislav Vishnevskiy (http://guildwork.com)- Matthew Scragg (http://www.ffxivpro.com)
Package: ffxivweather
ffxivweather-pyFFXIV weather forecast library for Python applications.Credit toGarland Toolsfor weather data, andXIVAPIandFFCafefor game data.Installationpip install ffxivweatherDocumentationThis package only exposes two methods:defget_forecast(place_name:str=None,terri_type_id:int=None,terri_type:str=None,count:int=1,second_increment:float=WEATHER_PERIOD,initial_offset:float=0*MINUTES,lang:LangKind=LangKind.EN)->list:"""Returns the next count forecast entries for the provided territory, at aseparation defined by second_increment and from the provided initial offset in seconds.Forecast entries are tuples in which the first item is the weather, and the second itemis the start time of that weather."""defget_current_weather(place_name:str=None,terri_type_id:int=None,terri_type:str=None,initial_offset:float=0*MINUTES,lang:LangKind=LangKind.EN):"""Returns the current weather and its start time, relative to the providedoffset in seconds, for the specified territory type."""ExampleCode:importdatetimeimportffxivweatherzone="Eureka Pyros"forecast=ffxivweather.forecaster.get_forecast(place_name=zone,count=15)print("Weather for "+zone+":")print("|\tWeather\t\t|\tTime\t|")print("+-----------------------+---------------+")forweather,start_timeinforecast:fmt1=weather["name_en"]if(len(weather["name_en"])<8):fmt1+="\t"fmt2=str(round((start_time-datetime.datetime.utcnow()).total_seconds()/60))print("|\t"+fmt1+"\t|\t"+fmt2+"m\t|")Output:Weather for Eureka Pyros:
|       Weather         |       Time    |
+-----------------------+---------------+
|       Snow            |       -13m    |
|       Heat Waves      |       10m     |
|       Thunder         |       33m     |
|       Heat Waves      |       57m     |
|       Fair Skies      |       80m     |
|       Umbral Wind     |       103m    |
|       Snow            |       127m    |
|       Umbral Wind     |       150m    |
|       Thunder         |       173m    |
|       Thunder         |       197m    |
|       Umbral Wind     |       220m    |
|       Snow            |       243m    |
|       Heat Waves      |       267m    |
|       Blizzards       |       290m    |
|       Thunder         |       313m    |
Package: ffzf
ffzfFast fuzzy string matching for Python.Installationpip install ffzfUsage# Find closest string matchingfromffzfimportclosestbest_match=closest("hello",["harps","apples","jello"])# Find n best matchesfromffzfimportn_closestbest_matches=n_closest("hello",["harps","apples","jello"],2)fromffzfimportJAROWINKLER# Specify an algorithm (default is levenshtein distance)best_match=closest("hello",["harps","apples","jello"],algorithm=JAROWINKLER)# Call algorithm directlyfromffzfimportlevenshtein_distancedist=levenshtein_distance("hello","jello")# Case sensitive comparison (default is case insensitive)dist=levenshtein_distance("Hello","hello",case_sensitive=True)best_match=closest("Hello",["harps","apples","jello"],case_sensitive=True)# Remove whitespace (default is to keep the whitespace in strings)dist=levenshtein_distance("hello world","helloworld",remove_whitespace=True)# Return scores with closest resultsfromffzfimportn_closest_with_scorebest_matches=n_closest_with_score("hello",["harps","apples","jello"],2)Supported AlgorithmsLevenshtein Distance (default)Jaro Similarity ("JARO")Jaro-Winkler Similarity ("JAROWINKLER")Hamming Distance ("HAMMING")
Package: fga_demo
Prototype 3 FGA ProjectSetupCreate a virtual environment:conda create -n <env_name> python=3.10Install the test package using the pip install commandProgram useProject initialization:Runfga initto provide user access creds and setup overall project, through responding to a series of prompts. Like shown belowProvide a project name default: [fga]: 
What region should your resources be provisioned in eg: eu-west-1?: 
What should we name the cluster? default: [eks-cluster]: 
What resource prefix should we use(an alphanumeric; 3-11 character limit)? default: [fga]: "provide a resource prefix"
Provide the IAM Access Key: "access key goes here"
Provide the AWS Secret key: "secret key goes here"
The fga directory already exists. Do you want to update its contents? [y/N]: y
Your project fga has been created here: /<dir-path>/fgaOn completion a dir path will be provided indicating where project has been setup.cd into the dir ie:cd <dir-path/fga>Provision the FGA resources.run command:fga provisionto deploy the FGA infrastructure.View extra commands here.run command:fga --helpto see other commands
Package: fgbio-postprocessing
fgbio_postprocessingUsage: simplex_filter [OPTIONS]Filter bam file to only simplex reads withmin_simplex_readson one
strandOptions:--input_bamTEXTPath to bam to be filtered  [required]--output_filenameTEXTName of output bam  [required]--min_simplex_readsINTEGERMinimum number of simplex reads to pass filter--helpShow this message and exit.CreditsThis package was created withCookiecutterand theaudreyr/cookiecutter-pypackageproject template.History0.1.0 (2020-08-25)First release on PyPI.
Package: fgcp-client-api
Note: This project has been migrated to GitHub athttps://github.com/mikespub/fgcp-client-apiPlease report any new issues there…Client API library for the Fujitsu Global Cloud Platform (FGCP)using XML-RPC API Version 2015-01-30Using this libraryIf you already have access to the Fujitsu Global Cloud Platform (FGCP), have a look at the demo script:**Usage:** fgcp_demo.py [pem_file] [region]If not, register on one of the Service Portals from the list below. Afterwards, you can access your resources
via command-line scripts, web interfaces etc. as you prefer.# Connect with your client certificate to region 'uk'fromfgcp.resourceimportFGCPVDataCentervdc=FGCPVDataCenter('client.pem','uk')# Do typical resource actionsvsystem=vdc.get_vsystem('Python API Demo System')vsystem.show_status()forvserverinvsystem.vservers:result=vserver.backup(wait=True)...Note: this client API library provides higher-level Client Methods, intermediate Resource Actions and lower-level API Commands.Fujitsu Global Cloud Platform (FGCP)Service Portal:for Australia and New Zealand:http://globalcloud.fujitsu.com.au/for Central Europe (CEMEA&I):http://globalcloud.de.fujitsu.com/for Japan:http://oviss.jp.fujitsu.com/for Singapore, Malaysia, Indonesia, Thailand and Vietnam:http://globalcloud.sg.fujitsu.com/for the UK and Ireland:http://globalcloud.uk.fujitsu.com/for the Americas:http://globalcloud.us.fujitsu.com/RequirementsThis module uses tlslite.utils or gdata.tlslite.utils to create the key signature, seehttps://pypi.python.org/pypi/tlslite-ngorhttps://pypi.python.org/pypi/tlslitefor download and installationNote: to convert your .p12 or .pfx client certificate to unencrypted PEM format, you can use the following ‘openssl’ command:openssl pkcs12 -in UserCert.p12 -out client.pem -nodes
Package: fgc-tools
Fancy Galaxy Code (FGC)Fancy Galaxy Code (FGC) is an open source standard for fast and reliable data representation while maintaining a nice look and feel.FGC strifes to serve as a prettier QR-Code straight from the future.Contributions and integrations into projects are highly appreciated!LinksPyPI PackageOnline FGC CreatorSpecificationData processing4 Version bitsn Data + Hamming Code correction bitsData representationGeneral structureCenter point is thick and has a fixed distance to the arc surrounding it, which equals the distance from layer to layer.The dot in the ring around the center point represents the orientation (0 degrees).For the exact distance calculations see the code.Every ring can store up to degrees_per_bit - 1 bits, since the first bit of every layer is always a 0.The degrees per bit can be looked up:Layer 1: 20° per bit = 360° / 20° - 1 bits = 17 bits 
Layer 2: 15° per bit
Layer 3: 12° per bit
Layer 4: 10° per bit
... 9, 8, 8, 6, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4 ...
After the last 4° layer (layer 19), every following layer (>= 20) has 3° per bit and can therefore store 360° / 3° -1 bits = 119 bitsData representationIf the next bit is the same as this bit: Draw an arcIf the next bit is not the same as this bit: Draw a dotVisual explanationFGC-tools package usageInstall the package via:pipinstallfgc-toolsImport the FGCCreator class and create an fgc:fromfgc_toolsimportFGCCreatorFGCCreator.create_fgc(color_inner="#009060",color_outer="#006090",data="Example",output_file="example.svg",color_background="#ffffff",write_data_as_text=True)Import the FGCReader and ReadResult class and read an fgc:fromfgc_toolsimportFGCReaderfromfgc_toolsimportReadResult# Read image from file pathread_result:ReadResult=FGCReader.read_image(image_path="example.jpg")# Read image from bytesread_result:ReadResult=FGCReader.read_image(image_file=myPreviouslyDefinedByteArray)Code executionIf you want to experiment with the code in this repository, install the requirements first:pip install -r requirements.txt