Saravanan666/pypi-org huggingface dataset:
Package: fc-tunnel
简介一个快速打通本地开发环境和阿里云云上 vpc 具体实例 tcp 网络的简洁工具快速开始前提条件本地已经有 python3.x本地已经安装了docker开通函数计算，并登录函数计算控制台， 第一次登录会引导您完成 FCDefaultRole 授权创建安装$pipinstallfc-tunnel编写配置文件 config.json, 例如:{"akId":"your aliyun ak id","akSecret":"your aliyun ak secret","accountId":"your aliyun main account id","region":"cn-beijing","vpcId":"vpc-2zes9muk32e82wwt7kfef","vSwitchIds":"vsw-2zek7r3kcvmu3div13bh4","securityGroupId":"sg-2zed3dvbh98kzoi3cch5","remoteIP":"10.20.108.195","remotePorts":"8080,9000"}其中：如果 ak 不是对应主账号或者具有 admin 权限的子账号， 请先给 ak 对应的子账号添加 FCFullAccess 和 自定义 RAM Policy:{"Statement":[{"Effect":"Allow","Action":"tns:*","Resource":"*"}],"Version":"1"}remoteIP 表示云上阿里云 vpc 的内网地址， 具体可以是 SAE 应用的实例内部 IP， ECI 实例的内部 IP， ECS 内网 IP 等remotePorts 对应 remoteIP 实例映射到本地的端口如上面的 config.json 所示， 如果您有一个 vpc 内置地址为 10.20.108.195 的 SAE 实例， 这个 SAE 实例上跑的是一个 java SpringBoot 的应用， 8080 是 web 服务端口， 9000 是远程调试的端口建立通道， 远程访问及调试$fct-cconfig.json耐心等待， 直到输出Session is OK! now you can remote debug, 注意不要关闭这个终端。以上面那个 config.json 为例， 这个时候：可以直接使用http://127.0.0.1:8080访问 SpringBoot 网站直接使用本地 IDE IDEA 上的源码对实例上的 jar 包进行远程调试在菜单栏选择 Run… > Edit Configurations 。新建一个 Remote Debugging 。自定义调试器名称，并将端口配置为 9000 。上述配置完成后，在 IDEA 编辑器侧边栏为函数代码增加断点，点击"开始调试"按钮。当然您也可以借助本地的代理容器实例，作为跳板机， 实现对云上具体实例的管理操作$dockerps-a|grepVPN-Local
d46a86c27abdregistry.cn-beijing.aliyuncs.com/aliyunfc/vpn-local-proxy:v0.0.1"/usr/app/start.sh"5minutesagoUp5minutes0.0.0.0:8080->8080/tcp,0.0.0.0:9000->9000/tcpVPN-Local-S-5ecc9bda-6d83-4f5d-884c-6739d8a3925e

$dockerexec-itd46a86c27abdbash
root@d46a86c27abd:/usr/app#telnet10.20.108.1958080Trying10.20.108.195...
Connectedto10.20.108.195.
Escapecharacteris'^]'.关闭通道调试完毕后， 直接CTRL+C结束建立通道命令执行的那个终端， 会自动执行清理 FC 资源操作， 尤其是会自动取消有付费的预留其他通道建立借助了  Serverless 的 FC 128M 实例,  FC的计费粒度精确到毫秒计费函数实例资源使用量：每月前400,000 GB-秒函数实例资源使用量免费即使不考虑每个月的免费额度，我们这里折算成小时， 也就是您调试 1h, 费用大约为 0.000110592元/GB-秒128/10243600 =0.0497 元FC 计费详情
Package: fcust
Folder CustodianLinux Common Folder CustodianFree software: GNU General Public License v3Documentation:Read the DocsWhy?The family computer runs Fedora, has many users and we want to share some files with each other.
To achive this we create a shared common folder.
This package solves the problems that come with our use case.FeaturesThis package is intended to perform maintenance over a folder shared across many users in a Fedora Workstation.
The folder should belong to a group for which all users are members.Go through a folder’s content and enforce common group ownership.Go through a folder’s content and enforce common group read and write permissions as
well as set groupid sticky bit.Provide a command line command with sane defaults for enforcing common folder group ownership
and permissions.Write logs to/tmp/fcust/$USER.log.Provides user systemd service to periodically enforce common folder group ownership
and permissions. Runs on user log out.The key problem this package intends to solve is that files moved from one location to another do not inherit
proper permissions in the commonly used folder and therefore when another user tries to access them they encounter
problems.Quick Start GuideInstall fcust:$ sudo dnf copr enable iolaum/fcust
$ sudo dnf install fcustManually create a common group and add as members the users that will have access to it.
For example:$ sudo groupadd family
$ sudo usermod -a -G family user1
$ sudo usermod -a -G family user1Create that folder and assign proper permissions:$ mkdir /path/to/common/folder/
$ chown :family /path/to/common/folder/
$ chmod 2775 /path/to/common/folder/Setup fcust:$ fcust setup /path/to/common/folder/
$ fcust activateIn order to run fcust manually on a properly permissioned common folder run:$ fcust run /path/to/common/folder/History1.0.0 (2020-11-21)Updated package for Fedora 35.Releasing production version.0.1.1 (2020-11-22)Added ability to see recent service logs.Releasing beta version of feature complete package.0.0.14 (2020-11-10)Adding functionality to create, start and stop systemd user service0.0.10 (2020-11-07)F33 releaseMinor Documentation update0.0.9 (2020-10-13)Hotfixed log access path bug0.0.8 (2020-10-10)Draft packaging as a fedora 32 rpm package0.0.5 (2020-10-07)Added command line command for folder contents permission enformcementAdded documentation0.0.3 (2020-10-05)Alpha version with common folder enformcement functionality.
Package: fcwslib
IntroductionA library that makes development of Python Minecraft Bedrock Edition websocket applications easier.InstallpipinstallfcwslibDemoimportfcwslibclassPlugin(fcwslib.Plugin):asyncdefon_connect(self):print('Connected')awaitself.send_command('list',callback=self.list)awaitself.subscribe('PlayerMessage',callback=self.player_message)asyncdefon_disconnect(self):print('Disconnected')asyncdefon_receive(self,response):print('Receive other response{}'.format(response))asyncdeflist(self,response):print('Receive command response{}'.format(response))asyncdefplayer_message(self,response):print('Receive event response{}'.format(response))server=fcwslib.Server()server.add_plugin(Plugin)server.run_forever()
Package: fcxai-alexandria
AlexandrIA LibsEverything for building and remodeling (your application) in one placePublished to PyPI at:https://pypi.org/project/fcxai-alexandria/Installation# productionpipinstallfcxai-alexandria# developmentpipinstall-e.[dev]Usageimportalexandriaasalx# alx.awslib# alx.galib# alx.s3libPublish# install publish dependenciespipinstall--upgradebuildtwine# buildpython-mbuild# uploadpython-mtwineuploaddist/*# use your pypi username and password
Package: fcx-playground
DocumentationSteps to Use1. Installation:pip install fcx-playground2. Usage:To use data processing steps for NAV:from fcx_playground.fcx_dataprocess.czml_nav import NavCZMLDataProcess
obj = NavCZMLDataProcess()

data = obj.ingest("<path_to_input>")
pre_processed_data = obj.preprocess(data)
czml_str = obj.prep_visualization(pre_processed_data)To use data processing steps for CRS rad-range:from fcx_playground.fcx_dataprocess.tiles_rad_range import RadRangeTilesPointCloudDataProcess
obj = RadRangeTilesPointCloudDataProcess()

data = obj.ingest("<path_to_input>")
pre_processed_data = obj.preprocess(data)
point_clouds_tileset = obj.prep_visualization(pre_processed_data)To visualize NAV CZML:from fcx_playground.fcx_cesium_viz.czml_viz import CZMLViz
czml_viz_obj = CZMLViz()
nav_czml_cesium_html = czml_viz_obj.generate_html("<path_to_saved_czml>")

# use the nav_czml_cesium_html in IPython.display.HTML to render it.To visualize CRS rad-range 3DTiles:from fcx_playground.fcx_cesium_viz.tiles_viz import TilesViz
tileset_viz_obj = TilesViz()
point_clouds_tileset_html = tileset_viz_obj.generate_html("<path_to_saved_point_clouds_tileset>")

# use the point_clouds_tileset_html in IPython.display.HTML to render it.Note:ingest,preprocess,prep_visualizationmethods are inherited fromDataProcessAbstract Class.As per need, we can override or write custom methods foringest,preprocess,prep_visualization, by maintaining consistency on the return type of the overrides.Steps to use fcx playground from Source CodePre-requisites1. General direction:InstallpythonInstallconda(optional but recommended)Use eitherpiporcondato install dependencies mentioned inrequirements.txtData are ingested from AWS S3. So,Setup AWS credentialsaws configurePreferred. This deployment configuration is assumed to be used.Needaws_access_key_id and aws_secret_access_keykey values; inside~/.aws/credentials2. Using DockerInstallDockerData are ingested from AWS S3. So,Setup AWS credentialsaws configurePreferred. This deployment configuration is assumed to be used.Needaws_access_key_id and aws_secret_access_keykey values; inside~/.aws/credentialsRundocker compose build(will take few minutes)Rundocker compose up, and note down thetoken_idUselocalhost:8888/tree?token=<token_id>to run Jupyter Notebook.Usage:notebooksdir contains all the interactive python notebooks to get started with various visualization file generations.srcdir contains modules that enables the visualization file generation.Abstact classes defines the highlevel process on which the raw data are manupulated.The concrete classes are implemented from abstract classes for detailed 3d visualization file generation processes.There are utilities that help the visualization file generation.Devloper guidelines:Clear Notebookoutputsbefore commiting any changes to git; for clean changes tracking.
Package: fda
Fourier Domain Adaption (FDA)This Python package implements a classic frequency domain adaptation, as shown in:FDA: Fourier Domain Adaptation for Semantic Segmentation, Yanchao Yang and Stefano Soatto, CVPR 2020Install with pip$ python3 -m pip install fda --userInstall from source$ python3 setup.py install --userExemplary code snippetimportfda# Read source and target imagessource_im=cv2.imread('source.jpg')target_im=cv2.imread('target.jpg')# Perform domain adaptationadapted_im=fda.fda(source,_im,target_im,beta=0.005)Run domain adaptation on a single image$ python3 -m fda.run --source source.jpg --target target.jpg --output output.jpg --beta 0.005Some examples of the domain adaptationSource imageTarget domain imageBetaOutput0.0010.010.10.0010.010.10.0010.010.1Run unit tests$ python3 tests/test_fourier.pyLicenseThis repository is shared under anMITlicense.AuthorLuis Carlos Garcia Peraza Herrera (luiscarlos.gph@gmail.com), 2020-2022.
Package: fdadb
UNMAINTAINEDPLEASE NOTE: this library is not actively maintained and receives
only minimal updates necessary.  Most of it is no longer in active use
at Ro.fdadbA Django wrapper forfda.govNational Drug Code (NDC) database.fdadbstores each row under one nameMedicationNameobject instead of having multiple drugs with the same name
next to each other, for example: In the NDC database there are around 21 Viagras (with different strengths)
so in such case we save theMedicationName: Viagraand under this name we store all the 21 instances.
This allows for better user experience when searching through the list of drugs.Setting Uppip install fdadbAddfdadbto yourINSTALLED_APPS./manage.py migrate fdadb./manage.py fetch_ndc_database- might take 15-30 minutes (the command will fetch all items from FDA database and save it in your project)API:All APIs are searchable with ?q=term query param.medications/Returns list ofMedicationNameobjects (pass?q=termtosearchto filter the results),
this API supports ElasticSearch for fast querying. Pagination does not work yet when ElasticSearch is enabled
(in most cases this does not cause any issues, as this API is generally used for drug autocomplete). You can change the
autocomplete limit by settingFDADB_AUTOCOMPLETE_LIMITin your Django configuration (default:10).The ElasticSearch uses ngram for the query parameter.medications/(?P<medication_name>[w-]+)/strengthsReturns list of medication strengthsmedications/(?P<medication_name>[w-]+)/strengths/(?P<strength_id>[d-]+)/ndcsReturns list of Medication NDCsElasticSearchTo enable support of ElasticSearch in autocomplete, set:ELASTICSEARCH_URLin project configurationRun./manage.py fdadb_es_indexafter fetching the NDC database (use--drop_indexesin case you want to cleanup the medications index)Manage.py commands./manage.py fdadb_es_index - indexes the products into ElasticSearch./manage.py fetch_ndc_database - fetches products data from NDS DB and saves in the databaseSupportDjango 1.11, 2.1, 2.2Python 3.4-3.6
Package: fdantic
FlaskDanticunião de duas lib, flask-restx e pydantic, para facilitar a criação de apis rest com pythonfromflaskimportFlaskfromflask_danticimportFDanticfromflask_restximportResourcefrompydanticimportBaseModel,validatorclassUsuario(BaseModel):id:intusername:strpassword:strapp=Flask(__name__)api=FDantic(app)np=api.namespace("grupo")user=np.model_pydantic(Usuario)classUsuarioResource(Resource):@user.validate(np)defpost(self):data:Usuario=self.payloadreturndata.dict()np.add_resource(UsuarioResource,"/")
Package: fdat
fdatFast Diffraction Analysis Toolfdat is a small software toolkit for easy visualization and lightweight analysis of diffractograms. It has been made for X-Ray diffractograms, but can ofcourse also be used for diffractograms from other radiation types like neutrons.Getting startedInstall fastdiff by cloning the repository and running the setup.pyCurrent features:Plotting of multiple diffractograms with possibility to zoom in on peaksSpecific-Peak detection for lattice constant determination (so far only Platina data added)DependenciesDans_Diffractionnumpy, matplotlib, scipy, pandas
Package: fdata
fdataThis tool is meant for the cleaning and creation of custom tables using FDA Adverse Event Reporting System (FAERS) data.Download whichever quarterly files (ASCII format) you wish to analyze, and utilize these functions to expedite cleaning and organization for your project!InstallationRun the following to install:pip install fdataNote: if there are empty lists initialized before the definition, the final output of the function will be attached to these built-in lists. See example below.Usageimport fdata as fd

drug_file = pd.read_csv(‘DRUG20Q1.txt’,  delimiter=‘$’)
fd.sorter(drug_file) 

	…

	“Check ‘class_dfs’, ‘missing_dfs’, ‘new_files’, ‘positives’, and ‘inds’ for output”

class_dfs = fd.class_dfs
missing_dfs = fd.missing_dfs

print(class_dfs)
print(missing_dfs)See function documentation for further details.
Package: fdate
# fdateFormats date string as 'yyyy-mm-dd' and manipulates date strings.Installation---------------Use one of the following method:* pip install```bashpip --install fdatepip --install fdate --upgrade```* clone repository and install with:```python setup.py install```Usage-------* InitializationsFrom a string of format 'yyyy-mm-dd', where the separator '-' can be any non-digital character.```python>>> from fdate import *>>> fd = Fdate('2018/4/7')>>> fd'2018-04-07'>>> fd = Fdate('2018-4-7')>>> fd'2018-04-07'```From exactly 8-length digits or Fdate object.```python>>> fd = Fdate('20180407')>>> fd'2018-04-07'>>> fe = Fdate(fd)>>> fe'2018-04-07'```From unix timestamp, with default time unit: second.```python>>> fd = Fdate().from_timestamp(1523030400)>>> fd'2018-04-07'```In case time unit is not second, say minisecond, set `unit=1000`.```python>>> fd = Fdate().from_timestamp(1523030400000, unit=1000)>>> fd'2018-04-07'```From function `today(shift=0)````python>>> fd = today()  # today>>> fd = today(-1)  # yesterday>>> fd = today(1)  # tomorrow```* Properties```python>>> fd = Fdate('20180407')>>> fd.year, fd. month, fd.day(2018, 4, 7)>>> fd.rank  # 2018-04-07 is the 97th day of the year.97>>> fd.is_weekendTrue>>> fd.is_workdayFalse>>> fd.is_leap_yearFalse>>> fd.is_first_day(of='M')  # first day of the ... ?  'M' -- month (default), 'Y' -- yearFalse>>> Fdate('2018-3-31').is_last_day()True>>> fd.to_timestamp() # to unix timestamp1523030400```* Calculations```python>>> fd = Fdate('20180407')>>> fd + 1'2018-04-08'>>> fd -= 1>>> fd'2018-04-06'>>> fd - '2018.3.6'31>>> fd - '2018/5/6'-30>>> fd > '2018-3-6'True>>> fd == '2018.4.6'True```* Iterations```python>>> [x for x in drange('2018-03-30', '2018-04-03')]['2018-03-30', '2018-03-31', '2018-04-01', '2018-04-02', '2018-04-03']>>> [x for x in drange('2018-04-03', '2018-03-30')]['2018-04-03', '2018-04-02', '2018-04-01', '2018-03-31', '2018-03-30']```
Package: fdb
Home*Documentation*Bug Reports*SourceFDB is aPythonlibrary package that implementsPython Database API 2.0-compliant support for the open source relational
databaseFirebird®. In addition to the minimal feature set of the standard Python DB API, FDB also exposes the entire native
(old-style) client API of the database engine. Notably:Automatic data conversion from strings on input.Automatic input/output conversions of textual data between UNICODE and database character sets.Support for prepared SQL statements.Multiple independent transactions per single connection.All transaction parameters that Firebird supports, including table access specifications.Distributed transactions.Firebird BLOB support, including support for stream BLOBs.Support for Firebird Events.Support for Firebird ARRAY data type.Support for all Firebird ServicesFDB also contains extensive collection of submodules that simplify various Firebird-related tasks. Notably:Database schemaFirebird monitoring tablesParsing Firebird trace & audit logsParsing Firebird server logParsing Firebird gstat utility output
Package: fdbk
fdbkBackend and DB wrapper for feedback collection system.InstallationRun:pipinstallfdbkto install fromPyPIor download this repository and runpythonsetup.pyinstallto install from sources.UsageSee examples directory for example use cases.Running the serverLaunch development server to port 8080 with:fdbk-server-p8080Seefdbk-server --helpfor other options.TestingCheck and automatically fix formatting with:pycodestylefdbk
autopep8-aaar--in-placefdbkRun static analysis with:pylint-E--enable=invalid-name,unused-import,useless-object-inheritancefdbkRun unit tests with command:python3-munittestdiscover-stst/Get test coverage with commands:coveragerun--branch--sourcefdbk/-munittestdiscover-stst/
coveragereport-m
Package: fdbk-dynamodb-plugin
fdbk_dynamodb_pluginAWS Dynamo DB wrapper for fdbk.InstallationRun:pipinstallfdbk_dynamodb_pluginto install fromPyPIor download this repository and runpythonsetup.pyinstallto install from sources.TestingCheck and automatically fix formatting with:pycodestylefdbk_dynamodb_plugin
autopep8-aaar--in-placefdbk_dynamodb_pluginRun static analysis with:pylint-E--enable=invalid-name,unused-import,useless-object-inheritancefdbk_dynamodb_pluginRun unit tests with command:python3-munittestdiscover-stst/Get test coverage with commands:coveragerun--branch--sourcefdbk_dynamodb_plugin/-munittestdiscover-stst/
coveragereport-mCloud deploymentIn addition to the plugin, this repository includes CloudFormation template for setting up the DynamoDB tables as well as the related IAM resources and a Chalice app that implements a simple serverless backend to view overview of the data.The CloudFormation template is available infdbk_tables.template.yaml. It setups both of the tables, topics and data, with pay-per-request billing mode.The chalice implementation for serverless backend is located inserverless-backend/. The application configuration inserverless-backend.chalice\config.jsonmust be updated with your environment specific resources. After updating the configuration, the app can be deplyed withchalicedeploy
Package: fdbk-mongodb-plugin
fdbk_mongodb_pluginMongoDB wrapper for fdbk.InstallationRun:pipinstallfdbk_mongodb_pluginto install fromPyPIor download this repository and runpythonsetup.pyinstallto install from sources.TestingCheck and automatically fix formatting with:pycodestylefdbk_mongodb_plugin
autopep8-aaar--in-placefdbk_mongodb_pluginRun static analysis with:pylint-E--enable=invalid-name,unused-import,useless-object-inheritancefdbk_mongodb_pluginRun unit tests with command:python3-munittestdiscover-stst/Get test coverage with commands:coveragerun--branch--sourcefdbk_mongodb_plugin/-munittestdiscover-stst/
coveragereport-m
Package: fdbk-ruuvi-reporter
fdbk_ruuvi_reporterGetting startedOriginally published ina Medium post.Following steps assume that you have some RuuviTags transmitting data near the Raspberry Pi. The steps also require some Raspberry Pi, Unix, and AWS knowledge:Setup a Raspberry Pi with a fresh Rasbian, connect it to internet, change your password, and optionally enable SSH.Install required software dependencies on the Raspberry Pi:sudoapt-getupdate
sudoapt-getinstallbluez-hcidumppython3python3-pip
sudopip3installfdbk_ruuvi_reporterfdbk_dynamodb_pluginCreate AWS DynamoDB tables and a reporter user withCloudFormation template.Create Access key for the reporter user in AWS. Configure the access keys and region to the~/.awsdirectory on the Raspberry Pi.On Raspberry Pi, create topics for your RuuviTags withfdbk-ruuvi-reporter --create-topic ${name} ${mac} --db-connection fdbk_dynamodb_pluginwhere${name}is the name for your sensor and${mac}is the MAC address of the RuuviTag.Try to run the reporter withfdbk-ruuvi-reporter -v -i 10 --db-connection fdbk_dynamodb_plugin, where-vis for verbose,-i 10sets data push interval to ten seconds, and--db-connection fdbk_dynamodb_pluginspecifies database connection to be used, here DynamoDB. Check from the AWS console that data is being transmitted.Configure fdbk-ruuvi-reporter to start on reboot withcrontab -e. For example, to transmit data every 15 minutes with output directed to file/home/pi/.reporter-log.txt, the crontab row would be:@reboot/usr/local/bin/fdbk-ruuvi-reporter-v-i900--db-connectionfdbk_dynamodb_plugin>/home/pi/.reporter-log.txtReboot the Raspberry Pi and check from the AWS console that data is being transmitted.To access the data via fdbk development server on your development computer: Installfdbkandfdbk_dynamodb_plugin. Configure AWS credentials with read access rights to both topics and data tables. Runfdbk-server, which is provided byfdbkpackage, with DynamoDB plugin as the DB connection:fdbk-server --db-connection fdbk_dynamodb_plugin. Navigate tohttp://localhost:8080/overviewto access overview of the data.DevelopmentInstallationRun:pipinstallfdbk_ruuvi_reporterto install fromPyPIor download this repository and runpythonsetup.pyinstallto install from sources.TestingCheck and automatically fix formatting with:pycodestylefdbk_ruuvi_reporter
autopep8-aaar--in-placefdbk_ruuvi_reporterRun static analysis with:pylint-E--enable=invalid-name,unused-import,useless-object-inheritancefdbk_ruuvi_reporterRun unit tests with command:python3-munittestdiscover-stst/Get test coverage with commands:coveragerun--branch--sourcefdbk_ruuvi_reporter/-munittestdiscover-stst/
coveragereport-m
Package: fdbm
FDBMFile data base system used to save/update/delete/find class objects to files easly.After you create your class you can do save, update, delete and find objects of that class instance without having to write code for these opertaions.Exemple:filetest_fdb.py:from pathlib import Path
from fdbm.model_base import FDBModel, FDBManager
from automotive_structure import Car, Engine


if __name__ == "__main__":
    
    #Set model path
    pathi = str((Path(__file__).parent).absolute())
    
    #Init model
    FDBModel.initialize(pathi)

    #Save class object
    myCar = Car('Peugeot', '504GL', 1970, 'Essence')
    myCar.saveNew()
    myCarObj = FDBModel.manager.find(type_of=Car, brand='Peugeot')

    #Save class object with subobject
    myEngine = Engine('Essence', 2.4, 'France')
    myCar = Car('Peugeot', '505GL', 1980, myEngine)
    myCar.saveNew()
    myCarObjList = FDBModel.manager.find(type_of=Car, brand='Peugeot')

    #Save class object with sub object with path arguemnt

    myEngine = Engine('Essence', 1.8, 'France')
    myCar = Car('Peugeot', '504GL', 1970, myEngine)
    myCar.saveNew('peugeot.pgt')
    myCarObjList = FDBModel.manager.get('peugeot.pgt')
      
    #Edit class object with sub object
    myCarObjList = FDBModel.manager.find(type_of=Car, brand='Peugeot')
    myCarObjList[2].model = '305'
    #sub object modification
    myCarObjList[2].engine.size = 1.6
    myCarObjList[2].update()

    myCarObjList = FDBModel.manager.find(type_of=Car, brand='Peugeot')

    #Delete one speicifc object
    isDeleted = FDBModel.manager.delete(myCarObjList[2])

    #List will have only two element
    myCarObjList = FDBModel.manager.find(type_of=Car, brand='Peugeot')

    #Delete all objects of type Car
    isDeleted = FDBModel.manager.deleteAll(type_of=Car)

    #List will have Zero element
    myCarObjList = FDBModel.manager.find(type_of=Car, brand='Peugeot')

    print('Done!')Fileautomotive_structure.pyfrom fdbm.fdb_base import FDBase
class Car(FDBase):
    
    def __init__(self, brand, model, year, engine):
        self.brand = brand
        self.model = model
        self.year = year
        self.engine = engine

class Engine(FDBase):
    
    def __init__(self, type, size, origine):
        self.type = type
        self.size = size
        self.origine = origineFDBM repo