Saravanan666/pypi-org huggingface dataset:
Package: fca-algorithms
FCA algorithmsThis is a module providing a set of commonly used algorithms in FCA, RCA, and some of its variants. Its general intention is to provide an easy to use API so that it's easier to create other programs using these algorithms. The main algorithm that calculates formal concepts isinclose, and, inthis version, it is implemented in C++. Considering this, the API is expected to behave somewhat acceptably.API ReferenceCLIFCAPlot a hasse diagram from a contextfca_cli-cinput.csv--show_hasseThe context is expected to be acsvwith the following formatnameattr1attr2obj1xobj2xobj3xxobj4Output filesfca_cli-cinput.csv--show_hasse--output_dirpath/to/folder/Will create two files, one representing the hasse graph, the other one with a concept for each line. The line is the index in the hasse graph.RCATo plot the hasse diagrams of the contexts 1 and 2 after applying RCA with existsfca_cli-kcontext_1.csvcontext_2.csv-rrelation_1_2.csvrelation_2_1.csv--show_hasseto specify operatorfca_cli-kcontext_1.csvcontext_2.csv-rrelation_1_2.csvrelation_2_1.csv--show_hasse-oforallFCA utilsModule for FCA basics such as retrieving concepts, drawing a hasse diagram, etcGetting formal conceptsIn batchfromfca.api_modelsimportContext,Conceptc=Context(O:List[str],A:List[str],I:List[List[int]])concepts=c.get_concepts(c)List[Concept]IncrementallyBy intentfromfca.api_modelsimportIncLatticel=IncLattice(attributes=['a','b','c','d'])l.add_intent('o1',[0,2])# numbers are the indices of the attributesl.add_intent('o2',[1,2])...By pairfromfca.api_modelsimportIncLatticel=IncLattice()l.add_pair('o1','a')l.add_pair('o2','b')l.add_pair('o2','a')...Getting association rulesfromfca.api_modelsimportContextc=Context(O,A,I)c.get_association_rules(min_support=0.4,min_confidence=1)Drawing hasse diagramfromfca.plot.plotimportplot_from_hassefromfca.api_modelsimportContextk=Context(O,A,I)k.get_lattice().plot()# plot receives a number of kwargs such as print_latex=True|Falsel=IncLattice(attributes=['a','b','c','d'])l.add_intent('o1',[0,2])# numbers are the indices of the attributesl.add_intent('o2',[1,2])...l.plot()ContributorsRamshell (Nicolas Leutwyler)
Package: fca-algorithms-cpp
FCA algorithms C++ ImplementationThis projects is the version of thefca_algorithmsPyPi module implemented in C++.PurposeThe goal of this project is to eventually replace totally the implementation of the Python library with backend C++, and just leave the Python interface.So far, the only ported algorithm is inclose.PerformanceUnsurprisingly, this implementation runs much faster than the one done totally in python. In the following, we can see an example of the difference in runtimes usingget_conceptsmethod from theContextclass of bothfca_algorithms<=0.2.xandfca_algorithms_cpp.After running these tests, I decided to use this library in thePython oneso that at least the code can take advantage of the faster implementation ofinclose.Future WorkAs said before, the ideal would be to fully implement the CPU-intensive algorithms in C++ and maintain the Python interface. Considering this, the goal would be to eventually replace the python code with full C++ one.UsageThere are one function and two classes that are exported to Pythonfromfca_algorithms_cppimportContextCpp,ConceptCpp,inclose# inclose: (List[str] -> List[str] -> List[List[int]]) -> List[ConceptCpp]inclose(['g1','g2'],['m1','m2','m3'],[[1,1,0],[0,1,0]])# ContextCpp: (List[str] -> List[str] -> List[List[int]]) -> List[ConctextCpp]c=ContextCpp(['g1','g2'],['m1','m2','m3'],[[1,1,0],[0,1,0]])c.G# ['g1', 'g2']c.M# ['m1', 'm2', 'm3']C.I# [[1, 1, 0], [0, 1, 0]]# ConceptCpp: (ContextCpp, List[int], List[int]) -> ConceptCppconcept=ConceptCpp(c,[0,1],[1,2])# ({g1, g2}, {m2, m3})concept.X# [0, 1]concept.Y# [1, 2]Incremental LatticeBy intentThis implementation follows the article:AddIntentk=ContextCpp([],['a','b'],[])L=LatticeCpp(k)# Lattice: { ({ }, { a, b })}L.add_intent('o1',[1])# Lattice: { ({ }, { a, b }), ({ o1 }, { b })}L.add_intent('o2',[1])# Lattice: { ({ }, { a, b }), ({ o1, o2 }, { b })}L.add_intent('o3',[0])# Lattice: { ({ }, { a, b }), ({ o1, o2 }, { b }), ({ o1, o2, o3 }, { }), ({ o3 }, { a })}By pairk=ContextCpp([],[],[])L=LatticeCpp(k)# Lattice: {  }L.add_pair('o1','a2')# Lattice: Lattice: { ({ o1 }, { a2 })}L.add_pair('o2','a3')# Lattice: { ({ o1 }, { a2 }), ({ }, { a2, a3 }), ({ o1, o2 }, { }), ({ o2 }, { a3 })}L.add_pair('o3','a1')# Lattice: { ({ o1 }, { a2 }), ({ }, { a2, a3, a1 }), ({ o1, o2, o3 }, { }), ({ o2 }, { a3 }), ({ o3 }, { a1 })}L.add_pair('o3','a2')# Lattice: { ({ o1, o3 }, { a2 }), ({ }, { a2, a3, a1 }), ({ o1, o2, o3 }, { }), ({ o2 }, { a3 }), ({ o3 }, { a1, a2 })}Delete instanceThis implementation follows the article:DeleteInstancek=ContextCpp(['o1','o2','o3'],['a1','a2','a3'],[[0,1,0],[0,0,1],[1,1,0]])L=LatticeCpp(k)# Lattice: { ({ }, { a1, a2, a3 }), ({ o1, o3 }, { a2 }), ({ o1, o2, o3 }, { }), ({ o2 }, { a3 }), ({ o3 }, { a1, a2 })}L.delete_instance('o3')# Lattice: { ({ }, { a1, a2, a3 }), ({ o1 }, { a2 }), ({ o1, o2 }, { }), ({ o2 }, { a3 })}
Package: fcache
fcache is a dictionary-like, file-based cache module for Python. It’s simple
to use, has an optional write buffer, and isShelf-compatible.>>>fromfcache.cacheimportFileCache>>>mycache=FileCache('myapp')>>>mycache['foo']=[1,2,3,4,5]>>>mycache['foo'][1,2,3,4,5]>>>mycache['bar']='value'>>>list(mycache)['foo','bar']>>>delmycache['foo']>>>mycache['foo']...KeyError:'foo'withFileCache('myapp')asmycache:mycache['foo']=[1,2,3,4,5]InstallTo install fcache, use pip:$pipinstallfcacheDocumentationfcache’s documentationcontains an introduction along with an API overview. For more information on how to get started with fcache, be sure to read the documentation.Bug/Issues Trackerfcache uses itsGitHub Issues pageto track bugs, feature requests, and support questions.Licensefcache is released under the OSI-approvedMIT License. See the file LICENSE.txt for more information.
Package: fcal
InstallationpipinstallfcalUsage# Print the last 10 days in the default formatfcal-b10# Print the last 10 days in MM-DD formatfcal-b10-f'%m-%d'# Print the last 10 days and next 10 days in local datetime format %cfcal-b10-a10-f'%c'# Skip the dates until the next year skiping every 7 days.fcal-a365-s7Date DirectivesDirectiveMeaningExample%AWeekday as locale’s abbreviated name.Sun, Mon,%AWeekday as locale’s full name.Sunday, Monday, …, Saturday%dDay of the month as a zero-padded decimal number.01, 02, …, 31%-dDay of the month as a decimal number.1, 2, …, 31%BMonth as locale’s full name.January, February, …, December%mMonth as a zero-padded decimal number.01, 02, …, 12%-mMonth as a decimal number.1, 2, …, 12%yYear without century as a zero-padded decimal number.00, 01, …, 99%YYear with century as a decimal number.2001, 2010, …, 2093%%A literal'%'character.%DevelopmentTo build the package locally, runpython -m buildUploading to twine, which only package authors can do, is done using twine. To test the package locally, runpip install .
Package: fca-lazy-clf
Installation$pipinstallfca_lazy_clfRequirementsThe train and test datasets must be represented aspandas.DataFrame. The classifier uses only attributes of typesnumpy.dtype('O'),np.dtype('int64')and attributes with 2 any values. Other attributes will not be used. The target attribute must be binary.Example>>>importfca_lazy_clfasfca>>>importpandasaspd>>>fromsklearnimportmodel_selection>>>data=pd.read_csv('https://datahub.io/machine-learning/tic-tac-toe-endgame/r/tic-tac-toe.csv')>>>data.head()TLTMTRMLMMMRBLBMBRclass0xxxxooxooTrue1xxxxoooxoTrue2xxxxooooxTrue3xxxxooobbTrue4xxxxoobobTrue>>>X=data.iloc[:,:-1]# All attributes except the last one>>>y=data.iloc[:,-1]# Last attribute>>>X_train,X_test,y_train,y_test=model_selection.train_test_split(X,y,test_size=0.33,random_state=0)>>>clf=fca.LazyClassifier(threshold=0.000001,bias='false')>>>clf.fit(X_train,y_train)>>>clf.score(X_test,y_test)0.9716088328075709
Package: fcalc
FcalcEste pacote fornece mÃ³dulos relacionadas ÃmatemÃ¡tica financeira. A expectativa Ã© que possa ser de valia para pessoas que lidam com cÃ¡lculo financeiros, que envolvem taxa de juros, cÃ¡lculo de parcelas, montante e outros assuntos ligados ao setor. Testei no python 3.9.12InstalaÃ§Ã£oUse o gerenciador de pacotespippara instalar FcalcpipinstallfcalcAutorEdneudo BarrosLicenÃ§aMITReferÃªnciasMatemÃ¡tica EssencialMatemÃ¡tica financeiraMatemÃ¡tica FinanceiraMatemÃ¡tica FinanceiraMatemÃ¡tica Financeira com Uso da HP-12CPrincipais funÃ§Ãµes e aplicaÃ§Ãµes da calculadora HP 12C na MatemÃ¡tica Financeira para o Curso de CiÃªncias ContÃ¡beisFluxos de caixa com a calculadora HP12CCalculadora do cidadÃ£oMatemÃ¡tica financeiraMatemÃ¡tica financeiraCÃ¡lculo financeiroMatemÃ¡tica financeiraMatemÃ¡tica financeiraApostila matemÃ¡tica financeiraMatemÃ¡tica financeira
Package: fcapsy
fcapsyThefcapsyprovides experimental implementations of some psychological phenomena (e.g. typicality, basic level) which appears in field ofCognitive Psychology.Library is based onFormal Concept Analysisframework which is provided by greatconcepts library.⚠️ Library is mainly used in research. API can change rapidly.InstallationPackage is avaliable in alpha version viapip.$pipinstallfcapsyExperimentsSet of experiments is avaliable infcapsy-experimentspackage.Used in papersBelohlavek, R., & Mikula, T. (2020). Typicality in Conceptual Structures Within the Framework of Formal Concept Analysis. Proceedings of CLA 2020, 33-45.http://ceur-ws.org/Vol-2668/paper2.pdfBelohlavek, R., & Mikula, T. (2021). Typicality: A formal concept analysis account. International Journal of Approximate Reasoning.https://doi.org/10.1016/j.ijar.2021.12.001Based on papersBelohlavek, R., & Trnecka, M. (2020). Basic level of concepts in formal concept analysis 1: formalization and utilization. International Journal of General Systems, 1-18.Dependenciesfcapsy requires:Python (>= 3.7)conceptsbinsdpy
Package: fcapsy-experiments
fcapsy-experiments📦 Package of experiments forfcapsylibrary.⚠️ Library is mainly used in research. API can change rapidly.InstallationPackage is avaliable in alpha version viapip.$pipinstallfcapsy-experimentsUsed in papersBelohlavek, R., & Mikula, T. (2020). Typicality in Conceptual Structures Within the Framework of Formal Concept Analysis. Proceedings of CLA 2020, 33-45.http://ceur-ws.org/Vol-2668/paper2.pdfBelohlavek, R., & Mikula, T. (2021). Typicality: A formal concept analysis account. International Journal of Approximate Reasoning.https://doi.org/10.1016/j.ijar.2021.12.001Dependenciesfcapsy-experiments requires:fcapsyplotlypandasnumpysklearnfuzzycorrbinsdpy
Package: fcast
fcastDescriptionfcastis a collection of python tools used for forecasting flood events and their impact on transportation infrastructure. The following datasets are used:The NHDPlus V2.1 datasetStaged Elevation fromThe National Map.FTP LINKUSGS National Transportation Dataset (NTD)The National Water Model (NWM)More informationInstallationSeehttps://dewberry.github.io/fcast/setup/for installation details.Contentsfcast- The collection of core .py files.GageUSGS: An API for webscraping stream gage data from various USGS websites.NHDPlusStreamSegment: An API for quick and easy access to the NHDPlus V2.1.NWM: An API for quick and easy access to theNWM output files.plotting: Functions for plotting using matplotlib and pandas.notebooks- The collection ofJupyter Notebooksrunning the code in the fcast subdirectory. Jupyter Notebooks are used because they produce easy, reproducible, and accesible outputs.MediumRangeForecasts: Retrieve the medium range forecast of streamflow from the outputs of the National Water Model. More information can be foundhere under Forecast Configurations.NWM_classes-Dev: Development space for NWM class objects.ShortRangeForecasts: Retrieve the short range forecast of streamflow from the outputs of the National Water Model. More information can be foundhere under Forecast Configurations.USGS_Gages: Example usage of the GageUSGS class.clean_GageLoc_shp: The notebook used to clean and add attributes to the GageLoc shapefile. The output shapefile/json is used to easily match ComIDs with USGS gage IDs.compare_rc_NWM_USGS-Dev: Development space for comparing rating curves from the National Water Model to the rating curves from the USGS.explore_NHDPlus-Dev: Development space for the StreamSegmentNHD class.notebooks/data_exploration- A collection of Jupyter notebooks used for exploring 1D and 2D NWM rating curves and retrieving NWM HAND datasets.rating_curves: Exploration and comparison of thehydroprop-fulltable-HUC6.nohand0.csvandhydroprop-fulltable-HUC6.csvrating curve files.rating_curves_1D_nc: Exploration of rating curves from the NWM 1D netcdf file.rating_curves_2D_nc: Exploration of rating curves from the NWM 2D netcdf file.retrieve_HAND_datasets: Download of HAND datasets for data exploration.reanalysis- An initial look at the NWM reanalysis netcdf files.Clean_data_By_date: Organizing downloaded data by dates.Download_Reanalysis_Data: Downloading reanalysis netcdf files from s3.Plot: Plotting NWM reanalysis data.Time_series: Making a time series at a specific ComID.explore_reanalysis-Dev: A notebook for downloading a time series of reanalysis data from s3 and making a streamflow time series plot at one ComID.reanalysis: Functions used in theexplore_reanalysis-Devnotebook.View the Documentation
Package: fcast-client
FCAST_Client Wrapper DocumentationThis is a Python client wrapper for the video streaming receiver found atfcast on GitLab. TheFCAST_Clientclass provides an easy-to-use interface to communicate with the reciever and control video playback.InstallationEnsure you have Python installed and the required libraries. This wrapper uses thesocket,json, andstructlibraries which are part of the Python standard library.UsageFirst, create an instance of theFCAST_Client:client=FCAST_Client(host="your_host_here",port=46899)MethodsplayPlays a video.client.play(container="video/mp4",url="http://example.com/video.mp4")Parameters:container: The MIME type (e.g., "video/mp4").url: The URL to load (optional).content: The content to load (e.g., a DASH manifest, optional).time: The time to start playing in seconds (optional).pausePauses the video.client.pause()resumeResumes the video.client.resume()stopStops the video.client.stop()seekSeeks to a specific time in the video.client.seek(time=120)# Seeks to 2 minutes into the video.Parameters:time: The time to seek to in seconds.set_volumeSets the volume of the video.client.set_volume(volume=0.5)# Sets the volume to 50%.Parameters:volume: The volume level (0.0 - 1.0).closeCloses the connection to the reciever.client.close()Example of Usage withfcastTo use theFCAST_Clientwrapper with thefcastreciever, follow the steps below:Ensure thefcastreciever is running and listening on the desired host and port.Create an instance of theFCAST_Clientand connect to thefcastreciever:fromfcastimportFCAST_Client# Replace with the appropriate host and port of your fcast recieverclient=FCAST_Client(host="your_host_here",port=46899)Play a video:# Play a video from a URLclient.play(container="video/mp4",url="http://example.com/video.mp4")Control the video playback:importtime# Pause the video after 5 secondstime.sleep(5)client.pause()# Resume playback after another 5 secondstime.sleep(5)client.resume()# Seek to 2 minutes into the video after 5 secondstime.sleep(5)client.seek(time=120)# Adjust the volume to 50%client.set_volume(volume=0.5)Once done, close the connection:client.close()
Package: fc-bench
Thefc_benchPython package allows to benchmark functions and much moreIntroduction:More documentation is available onfc_bench Python packagededicated web page with anUser’s Guide(pdf).Installation:Thefc_benchPython package is available from the Python Package Index, so to install/upgrade simply typepip install fc_bench -UTesting :There are demos functions in thefc_bench.demosmodule namedbench_*.
For example, run the following code under Python:fromfc_benchimportdemosdemos.bench_Lagrange()The output of this code is:#---------------------------------------------------------------------------
# Setting inputs of Lagrange polynomial functions: y=LAGRANGE(X,Y,x)
# where X is numpy.linspace(a,b,n+1), Y=fun(X) and x is random values on [a,b]
#   n is the order of the Lagrange polynomial
#   fun function is: lambda x: np.sin(x)
#   [a,b]=[-1,1]
#   X: (n+1,) numpy array
#   Y: (n+1,) numpy array
#   x: (m,)   numpy array
#   Error[i] computed with fun[i] output:
#     lambda y: np.linalg.norm(y-fun(x),np.inf)
#---------------------------------------------------------------------------
# Benchmarking functions:
#   fun[0],            Lag: fc_bench.demos.Lagrange
#   fun[1],         lagint: fc_bench.demos.lagint
#---------------------------------------------------------------------------
# Comparative functions:
#   comp[i-1,0], compares outputs of fun[0] and fun[i]
#       lambda o1,o2: np.linalg.norm(o1-o2,np.inf)
#    For each comparative function:
#      - 1st input parameter is the output of fun[0]
#      - 2nd input parameter is the output of fun[i]
#---------------------------------------------------------------------------
#date:2019-12-21_16-56-34
#nbruns:5
#numpy:     <i8    <i8       f8           f8          f8           f8          f8
#format:  {:>5}  {:>5}  {:6.3f}     {:10.3e}     {:9.3f}     {:10.3e}     {:9.3e}
#labels:      m      n   Lag(s)     Error[0]   lagint(s)     Error[1]     comp[0]
            100      3    0.014    1.218e-03       0.019    1.218e-03   2.220e-16
            100      5    0.021    1.162e-05       0.028    1.162e-05   4.441e-16
            100      7    0.030    6.999e-08       0.037    6.999e-08   3.331e-16
            100     11    0.048    8.699e-13       0.056    8.689e-13   2.554e-15
            500      3    0.068    1.218e-03       0.095    1.218e-03   3.331e-16
            500      5    0.108    1.163e-05       0.144    1.163e-05   6.661e-16
            500      7    0.152    7.004e-08       0.190    7.004e-08   8.882e-16
            500     11    0.244    8.766e-13       0.282    8.766e-13   2.887e-15
Package: fcbf
Implementation of the fast correlation-based filter (FCBF) proposed by Yu and Liu:@inproceedings{inproceedings,
author = {Yu, Lei and Liu, Huan},
year = {2003},
month = {01},
pages = {856-863},
title = {Feature Selection for High-Dimensional Data: A Fast Correlation-Based Filter Solution},
volume = {2},
journal = {Proceedings, Twentieth International Conference on Machine Learning}
}
Package: fcbypass
FcBypassA python module to get Funcaptcha tokens from capbypassCreate a FcBypass instanceimportFcBypassfcbypass=FcBypass.Solver(Key="ENTER_YOUR_CAPBYPASS_KEY_HERE")The variablefcbypasscan then be used multiple times to fetch tokens from capbypass.Use casesSignup:response=fcbypass.FunCaptchaTask(blob="Submit your blob String here",proxy="http://username:password@ip:port",Signup=True)print(response.Token)Login:response=fcbypass.FunCaptchaTask(blob="Submit your blob String here",proxy="http://username:password@ip:port",Login=True)print(response.Token)Action:response=fcbypass.FunCaptchaTask(blob="Submit your blob String here",proxy="http://username:password@ip:port",Action=True)print(response.Token)Your response.Token
Package: fcc
A pleasant interface for the United States Federal Communications Commission (FCC) data transparency services.Other WorkSure, there’s <https://github.com/codeforamerica/FCC-Python-Egg>, but I’m not a fan of the name and it hasn’t been updated in a couple years (as of 2014-Mar-12).InstallationLike most other PyPI packages.pip install fccOr download the source code and runsetup.pypython setup.py installUsageImport the wrapper functions to use in your code.>>> from fcc.census_block_conversions import census_block_fips
>>> census_block_fips(34.86,-111.79)
'040250018012017'Or use the simple command line script.$ census_block_conversions 34.86 -111.79
040250018012017
$ echo '34.86,-111.79' > coordinates.csv
$ census_block_conversions < coordinates.csv
040250018012017
Package: fcc2zim
freeCodeCamp scraperThis scraper downloads selectedfreeCodeCampcourses and puts it in aZIMfile, a clean and user friendly format for storing content for offline usage.ArchitectureThis project consists of two major components:zimui- A Vue.JS application specially crafted to:be embeded inside the ZIM and serve as main entry point (through compilation for offline usage with Vite)present FCC curriculum, including solving exercicesbe compatible with most ZIM readersscraper- The Python tool that build FCC ZIM. It is responsible to:fetch FCC curriculum and package it into a proper formatembed client can read, as well as our zim builderDependenciesAside Node.JS and Python dependencies which are managed, other binary dependencies comes from PythonzimscraperlibDevelopmentSeeCONTRIBUTING.md.PrerequisitesNode 20.xPython 3.11Running scraper locallyYou have to:build thezimuifrontend which will be embededed inside the ZIM (and redo it every time you make modifications to thezimui)run thescraperto retrieve FCC curriculum and build the ZIMSample commands:cd zimui
yarn install
yarn build
cd ../scraper
hatch run fcc2zim --language eng --course "regular-expressions,basic-javascript,basic-data-structures,debugging,functional-programming,object-oriented-programming,basic-algorithm-scripting,intermediate-algorithm-scripting,javascript-algorithms-and-data-structures-projects" --name "fcc_en_javascript" --title "freeCodeCamp Javascript" --description "FCC Javascript Courses"Running scraper with DockerRun from official version (published on GHCR.io) ; ZIM will be available in theoutputsub-folder of current working directory.docker run --rm -it -v $(pwd)/output:/output ghcr.io/openzim/freecodecamp:latest fcc2zim --language eng --course "regular-expressions,basic-javascript,basic-data-structures,debugging,functional-programming,object-oriented-programming,basic-algorithm-scripting,intermediate-algorithm-scripting,javascript-algorithms-and-data-structures-projects" --name "fcc_en_javascript" --title "freeCodeCamp Javascript" --description "FCC Javascript Courses"Course Options and LimitationsCurrently this scraper only supports Javascript challenges. A list of courses is passed to the scraper as a comma seperated list of 'course slugs'.You can find a list of course slugs in thefreeCodeCamp curriculum folderIn docker example above, see the--courseargument :regular-expressions,basic-javascript,basic-data-structures,debugging,functional-programming,object-oriented-programming,basic-algorithm-scripting,intermediate-algorithm-scripting,javascript-algorithms-and-data-structures-projects
Package: fcc_complaints
# fcc_complaints
FCC Complaints is a library to wrap the FCC’s Consumer Complaints Data.  The authors of this library have no affiliation with the FCC or the US government.Individual informal consumer complaint data detailing complaints filed with the Consumer Help Center beginning October 31, 2014. This data represents information selected by the consumer. The FCC does not verify the facts alleged in these complaints.[1](https://opendata.fcc.gov/Consumer/CGB-Consumer-Complaints-Data/3xyp-aqkj)This api and library aim to make it easier to look up complaints made against numbers to the FCC.The number of requests you can make on the data is limited unless you sign up for an API token.# Installation` pip install fcc_complaints `# Configuration
Setup a file in either~/.fcc_complaintsor/etc/default/fcc_complaintswith your FCC API settings.
Sign up at the FCC website for a token:https://opendata.fcc.gov/profile/app_tokensThe configuration file should look something like this:` [auth] app_token = {{YOUR APP TOKEN}} username = {{YOUR USERNAME}} `This is not required but allows you to not have to pass it in every time you initialize the api.  You can also provide the API tokens when you initialize the API.  If no tokens are provided you can still use the API but you will be limited in how many requests you can make by the FCC.# Usage` from fcc_complaints import FccApi api = FccApi() r =api.query(caller_id_number='0000000000')`The library will handling formatting of dates, phone numbers, etc. See the api documentation for more information on options.
Package: fcc-fourier
яю#\x00 \x00A\x00d\x00a\x00p\x00t\x00i\x00v\x00e\x00 \x00F\x00o\x00u\x00r\x00i\x00e\x00r\x00 \x00t\x00r\x00a\x00n\x00s\x00f\x00o\x00r\x00m\x00
\x00
\x00
\x00
\x00
\x00
\x00