"variable already declared" error due to circular imports

[elad]

I have compiled contracts with circular imports before, and hadn't got any errors. for some reason while compiling the following contracts

//webAddress: https://etherscan.io/address/0x1985365e9f78359a9B6AD760e32412f4a445E862#code
//comparedWebAddress: None
//fileName: ethereum\Compound\ReputationToken\Order
//SPDX-License-Identifier: UNLICENSED
pragma solidity 0.4.20;
import './SafeMathUint256.sol';
import './IOrders.sol';
import './IAugur.sol';
import './IController.sol';
import './IMarket.sol';
import './IShareToken.sol';





library Order {

    using SafeMathUint256 for uint256;



    enum Types {

        Bid, Ask

    }



    enum TradeDirections {

        Long, Short

    }



    struct Data {

        // Contracts

        IOrders orders;

        IMarket market;

        IAugur augur;



        // Order

        bytes32 id;

        address creator;

        uint256 outcome;

        Order.Types orderType;

        uint256 amount;

        uint256 price;

        uint256 sharesEscrowed;

        uint256 moneyEscrowed;

        bytes32 betterOrderId;

        bytes32 worseOrderId;

    }



    //

    // Constructor

    //



    // No validation is needed here as it is simply a librarty function for organizing data

    function create(IController _controller, address _creator, uint256 _outcome, Order.Types _type, uint256 _attoshares, uint256 _price, IMarket _market, bytes32 _betterOrderId, bytes32 _worseOrderId) internal view returns (Data) {

        require(_outcome < _market.getNumberOfOutcomes());

        require(_price < _market.getNumTicks());



        IOrders _orders = IOrders(_controller.lookup("Orders"));

        IAugur _augur = _controller.getAugur();



        return Data({

            orders: _orders,

            market: _market,

            augur: _augur,

            id: 0,

            creator: _creator,

            outcome: _outcome,

            orderType: _type,

            amount: _attoshares,

            price: _price,

            sharesEscrowed: 0,

            moneyEscrowed: 0,

            betterOrderId: _betterOrderId,

            worseOrderId: _worseOrderId

        });

    }



    //

    // "public" functions

    //



    function getOrderId(Order.Data _orderData) internal view returns (bytes32) {

        if (_orderData.id == bytes32(0)) {

            bytes32 _orderId = _orderData.orders.getOrderId(_orderData.orderType, _orderData.market, _orderData.amount, _orderData.price, _orderData.creator, block.number, _orderData.outcome, _orderData.moneyEscrowed, _orderData.sharesEscrowed);

            require(_orderData.orders.getAmount(_orderId) == 0);

            _orderData.id = _orderId;

        }

        return _orderData.id;

    }



    function getOrderTradingTypeFromMakerDirection(Order.TradeDirections _creatorDirection) internal pure returns (Order.Types) {

        return (_creatorDirection == Order.TradeDirections.Long) ? Order.Types.Bid : Order.Types.Ask;

    }



    function getOrderTradingTypeFromFillerDirection(Order.TradeDirections _fillerDirection) internal pure returns (Order.Types) {

        return (_fillerDirection == Order.TradeDirections.Long) ? Order.Types.Ask : Order.Types.Bid;

    }



    function escrowFunds(Order.Data _orderData) internal returns (bool) {

        if (_orderData.orderType == Order.Types.Ask) {

            return escrowFundsForAsk(_orderData);

        } else if (_orderData.orderType == Order.Types.Bid) {

            return escrowFundsForBid(_orderData);

        }

    }



    function saveOrder(Order.Data _orderData, bytes32 _tradeGroupId) internal returns (bytes32) {

        return _orderData.orders.saveOrder(_orderData.orderType, _orderData.market, _orderData.amount, _orderData.price, _orderData.creator, _orderData.outcome, _orderData.moneyEscrowed, _orderData.sharesEscrowed, _orderData.betterOrderId, _orderData.worseOrderId, _tradeGroupId);

    }



    //

    // Private functions

    //



    function escrowFundsForBid(Order.Data _orderData) private returns (bool) {

        require(_orderData.moneyEscrowed == 0);

        require(_orderData.sharesEscrowed == 0);

        uint256 _attosharesToCover = _orderData.amount;

        uint256 _numberOfOutcomes = _orderData.market.getNumberOfOutcomes();



        // Figure out how many almost-complete-sets (just missing `outcome` share) the creator has

        uint256 _attosharesHeld = 2**254;

        for (uint256 _i = 0; _i < _numberOfOutcomes; _i++) {

            if (_i != _orderData.outcome) {

                uint256 _creatorShareTokenBalance = _orderData.market.getShareToken(_i).balanceOf(_orderData.creator);

                _attosharesHeld = SafeMathUint256.min(_creatorShareTokenBalance, _attosharesHeld);

            }

        }



        // Take shares into escrow if they have any almost-complete-sets

        if (_attosharesHeld > 0) {

            _orderData.sharesEscrowed = SafeMathUint256.min(_attosharesHeld, _attosharesToCover);

            _attosharesToCover -= _orderData.sharesEscrowed;

            for (_i = 0; _i < _numberOfOutcomes; _i++) {

                if (_i != _orderData.outcome) {

                    _orderData.market.getShareToken(_i).trustedOrderTransfer(_orderData.creator, _orderData.market, _orderData.sharesEscrowed);

                }

            }

        }

        // If not able to cover entire order with shares alone, then cover remaining with tokens

        if (_attosharesToCover > 0) {

            _orderData.moneyEscrowed = _attosharesToCover.mul(_orderData.price);

            require(_orderData.augur.trustedTransfer(_orderData.market.getDenominationToken(), _orderData.creator, _orderData.market, _orderData.moneyEscrowed));

        }



        return true;

    }



    function escrowFundsForAsk(Order.Data _orderData) private returns (bool) {

        require(_orderData.moneyEscrowed == 0);

        require(_orderData.sharesEscrowed == 0);

        IShareToken _shareToken = _orderData.market.getShareToken(_orderData.outcome);

        uint256 _attosharesToCover = _orderData.amount;



        // Figure out how many shares of the outcome the creator has

        uint256 _attosharesHeld = _shareToken.balanceOf(_orderData.creator);



        // Take shares in escrow if user has shares

        if (_attosharesHeld > 0) {

            _orderData.sharesEscrowed = SafeMathUint256.min(_attosharesHeld, _attosharesToCover);

            _attosharesToCover -= _orderData.sharesEscrowed;

            _shareToken.trustedOrderTransfer(_orderData.creator, _orderData.market, _orderData.sharesEscrowed);

        }



        // If not able to cover entire order with shares alone, then cover remaining with tokens

        if (_attosharesToCover > 0) {

            _orderData.moneyEscrowed = _orderData.market.getNumTicks().sub(_orderData.price).mul(_attosharesToCover);

            require(_orderData.augur.trustedTransfer(_orderData.market.getDenominationToken(), _orderData.creator, _orderData.market, _orderData.moneyEscrowed));

        }



        return true;

    }

}

//webAddress: https://etherscan.io/address/0x1985365e9f78359a9B6AD760e32412f4a445E862#code

//comparedWebAddress: None

//fileName: ethereum\Compound\ReputationToken\IAugur

//SPDX-License-Identifier: UNLICENSED

pragma solidity 0.4.20;

import './IUniverse.sol';

import './ERC20.sol';

import './IMarket.sol';

import './Order.sol';

import './IFeeWindow.sol';

contract IAugur {

    function createChildUniverse(bytes32 _parentPayoutDistributionHash, uint256[] _parentPayoutNumerators, bool _parentInvalid) public returns (IUniverse);

    function isKnownUniverse(IUniverse _universe) public view returns (bool);

    function trustedTransfer(ERC20 _token, address _from, address _to, uint256 _amount) public returns (bool);

    function logMarketCreated(bytes32 _topic, string _description, string _extraInfo, IUniverse _universe, address _market, address _marketCreator, bytes32[] _outcomes, int256 _minPrice, int256 _maxPrice, IMarket.MarketType _marketType) public returns (bool);

    function logMarketCreated(bytes32 _topic, string _description, string _extraInfo, IUniverse _universe, address _market, address _marketCreator, int256 _minPrice, int256 _maxPrice, IMarket.MarketType _marketType) public returns (bool);

    function logInitialReportSubmitted(IUniverse _universe, address _reporter, address _market, uint256 _amountStaked, bool _isDesignatedReporter, uint256[] _payoutNumerators, bool _invalid) public returns (bool);

    function disputeCrowdsourcerCreated(IUniverse _universe, address _market, address _disputeCrowdsourcer, uint256[] _payoutNumerators, uint256 _size, bool _invalid) public returns (bool);

    function logDisputeCrowdsourcerContribution(IUniverse _universe, address _reporter, address _market, address _disputeCrowdsourcer, uint256 _amountStaked) public returns (bool);

    function logDisputeCrowdsourcerCompleted(IUniverse _universe, address _market, address _disputeCrowdsourcer) public returns (bool);

    function logInitialReporterRedeemed(IUniverse _universe, address _reporter, address _market, uint256 _amountRedeemed, uint256 _repReceived, uint256 _reportingFeesReceived, uint256[] _payoutNumerators) public returns (bool);

    function logDisputeCrowdsourcerRedeemed(IUniverse _universe, address _reporter, address _market, uint256 _amountRedeemed, uint256 _repReceived, uint256 _reportingFeesReceived, uint256[] _payoutNumerators) public returns (bool);

    function logFeeWindowRedeemed(IUniverse _universe, address _reporter, uint256 _amountRedeemed, uint256 _reportingFeesReceived) public returns (bool);

    function logMarketFinalized(IUniverse _universe) public returns (bool);

    function logMarketMigrated(IMarket _market, IUniverse _originalUniverse) public returns (bool);

    function logReportingParticipantDisavowed(IUniverse _universe, IMarket _market) public returns (bool);

    function logMarketParticipantsDisavowed(IUniverse _universe) public returns (bool);

    function logOrderCanceled(IUniverse _universe, address _shareToken, address _sender, bytes32 _orderId, Order.Types _orderType, uint256 _tokenRefund, uint256 _sharesRefund) public returns (bool);

    function logOrderCreated(Order.Types _orderType, uint256 _amount, uint256 _price, address _creator, uint256 _moneyEscrowed, uint256 _sharesEscrowed, bytes32 _tradeGroupId, bytes32 _orderId, IUniverse _universe, address _shareToken) public returns (bool);

    function logOrderFilled(IUniverse _universe, address _shareToken, address _filler, bytes32 _orderId, uint256 _numCreatorShares, uint256 _numCreatorTokens, uint256 _numFillerShares, uint256 _numFillerTokens, uint256 _marketCreatorFees, uint256 _reporterFees, uint256 _amountFilled, bytes32 _tradeGroupId) public returns (bool);

    function logCompleteSetsPurchased(IUniverse _universe, IMarket _market, address _account, uint256 _numCompleteSets) public returns (bool);

    function logCompleteSetsSold(IUniverse _universe, IMarket _market, address _account, uint256 _numCompleteSets) public returns (bool);

    function logTradingProceedsClaimed(IUniverse _universe, address _shareToken, address _sender, address _market, uint256 _numShares, uint256 _numPayoutTokens, uint256 _finalTokenBalance) public returns (bool);

    function logUniverseForked() public returns (bool);

    function logFeeWindowTransferred(IUniverse _universe, address _from, address _to, uint256 _value) public returns (bool);

    function logReputationTokensTransferred(IUniverse _universe, address _from, address _to, uint256 _value) public returns (bool);

    function logDisputeCrowdsourcerTokensTransferred(IUniverse _universe, address _from, address _to, uint256 _value) public returns (bool);

    function logShareTokensTransferred(IUniverse _universe, address _from, address _to, uint256 _value) public returns (bool);

    function logReputationTokenBurned(IUniverse _universe, address _target, uint256 _amount) public returns (bool);

    function logReputationTokenMinted(IUniverse _universe, address _target, uint256 _amount) public returns (bool);

    function logShareTokenBurned(IUniverse _universe, address _target, uint256 _amount) public returns (bool);

    function logShareTokenMinted(IUniverse _universe, address _target, uint256 _amount) public returns (bool);

    function logFeeWindowBurned(IUniverse _universe, address _target, uint256 _amount) public returns (bool);

    function logFeeWindowMinted(IUniverse _universe, address _target, uint256 _amount) public returns (bool);

    function logDisputeCrowdsourcerTokensBurned(IUniverse _universe, address _target, uint256 _amount) public returns (bool);

    function logDisputeCrowdsourcerTokensMinted(IUniverse _universe, address _target, uint256 _amount) public returns (bool);

    function logFeeWindowCreated(IFeeWindow _feeWindow, uint256 _id) public returns (bool);

    function logFeeTokenTransferred(IUniverse _universe, address _from, address _to, uint256 _value) public returns (bool);

    function logFeeTokenBurned(IUniverse _universe, address _target, uint256 _amount) public returns (bool);

    function logFeeTokenMinted(IUniverse _universe, address _target, uint256 _amount) public returns (bool);

    function logTimestampSet(uint256 _newTimestamp) public returns (bool);

    function logInitialReporterTransferred(IUniverse _universe, IMarket _market, address _from, address _to) public returns (bool);

    function logMarketTransferred(IUniverse _universe, address _from, address _to) public returns (bool);

    function logMarketMailboxTransferred(IUniverse _universe, IMarket _market, address _from, address _to) public returns (bool);

    function logEscapeHatchChanged(bool _isOn) public returns (bool);

}

i get the above error

[Skyge]

Could you please show more details? Which variable and maybe which line?

[elad]

of course, when compiling Iaugur I get the error: The previous declaration is here:
import './Order.sol'; (on line 15, while the import is in line 10). its important to note that the contract is succesfully compiled in remix d, i use py-solc-x which is a python wrapper for solc js